#include "StdAfx.h"
#include "oekologie.h"
#include "datenbank.h"
#include "gruenland.h"
#include "massnahme.h"
#include <math.h>
#include <list>

#define WURZEL(n,x) pow(x, 1.0/n)
using namespace std;

oekologie::oekologie( void)
{
}

oekologie::~oekologie( void)
{
}

double oekologie::whoeohe( int gruenlandzahl, int mv)
{
    double wuchsh;
    //check for wuchsklasse
    if( gruenlandzahl < niedrig)
    {
        //this corresponds to a slow groth of 2-3 cm each week
        double a = (rand() / ((double) RAND_MAX)); // produces a random number in [0,1]
        wuchsh = 5 + ((2 + a) * mv);

    } else
    {
        if( gruenlandzahl > mittel)
        {
            //this corresponds to a quick gorth of 4-5 cm each week
            double a = (rand() / ((double) RAND_MAX)); // produces a random number in [0,1]
            wuchsh = 5 + ((4 + a) * mv);
        } else
        {
            //this corresponds to a moderate groth of 3-4 cm each week
            double a = (rand() / ((double) RAND_MAX)); // produces a random number in [0,1]
            wuchsh = 5 + ((3 + a) * mv);
        }
    }

    return wuchsh;
}

double oekologie::wuchshoehe(
        int gruenlandzahl,
        int massnahmemv,
        int abstandm2,
		int abstandm3,
        int mv,
        bool hoch)
{
    double wuchsh;
	int wstart;

    if( hoch)
        wstart = start + 2;
	else
		wstart = start;

    if( mv < wstart)
        return 5;
    else
    {
        // check if mahd has just taken place
        int mvdif = mv - massnahmemv;
        if( !ref)
        {
            if( (mvdif == 0) || (mvdif == abstandm2)|| (mvdif == abstandm2 + abstandm3))
                return 5;
            else
            {

                if( mvdif < 0)
                    mvdif = mv - start; //das Monatsviertel ist vor der Mahd, aber nach dem start MV
                else
                {
                    if( mvdif > abstandm2+abstandm3)
                        mvdif = mvdif - (abstandm2+abstandm3);
					 else if( mvdif > abstandm2)
                        mvdif = mvdif - abstandm2;
                }
                wuchsh = whoeohe( gruenlandzahl, mvdif);
                return wuchsh;
            }
        } else //Referenz  mit 3 Schnitt
        {
            if( (mvdif == 0) || (mvdif == abstandm2) || (mvdif == 12))
                return 5;
            else
            {

                if( mvdif < 0)
                    mvdif = mv - start; //das Monatsviertel ist vor der Mahd, aber nach dem start MV
                else
                {
                    if( mvdif > 12)
                        mvdif = mvdif - 12;
                    else if( mvdif > abstandm2)
                        mvdif = mvdif - abstandm2;
                }
                wuchsh = whoeohe( gruenlandzahl, mvdif);
                return wuchsh;
            }
        }

    }

}
// Kombination aus der momentanen Wuchhoehe und dem Anspruch an die Wuchshoehe
double oekologie::whoehenanspruch(
        double hoehe,
        double anspruchhoch,
        double anspruchmittel,
        double anspruchkurz)
{
    if( hoehe < 10)
        return anspruchkurz;
    else
    {
        if( hoehe > 30)
            return anspruchhoch;
        else
            return anspruchmittel;
    }
}

//Massnahmezeitpunkt unabhängige Habitateignung Q_j^0)
double oekologie::massnahmeunabhaengigequalitaet(
        int wald,
        int wasser,
        int siedlung,
        double anspruchwald,
        double anspruchsiedlung,
        double anspruchwasser,
        double feucht,
        double frisch,
        double trocken,
        double anspruchfeucht,
        double anspruchfrisch,
        double anspruchtrocken,
        double praedation)
{
    double qualitaet;
    double feuchte = 0;
    double struktur = 1;
    //double praed = 1;
    //Berechnung von S
    if( wald == 0)
        struktur = 1 - anspruchwald;
    if( wasser == 0)
        struktur = struktur * (1 - anspruchwasser);
    if( siedlung == 0)
        struktur = struktur * (1 - anspruchsiedlung);
    struktur = WURZEL(3,struktur);

    int z = 0;
    //Berechnung von F
    if( feucht > 0)
    {
        z = z + 1;
        feuchte = feucht * anspruchfeucht;

    }
    //else
    //feuchte = feucht * anspruchfeucht;

    if( frisch > 0)
    {
        z = z + 1;
        feuchte = feuchte + (frisch * anspruchfrisch);
    }

    if( trocken > 0)
    {
        z = z + 1;
        feuchte = feuchte + (trocken * anspruchtrocken);
    }

    //double nf = 1/z;
    feuchte = feuchte / z;

    CString str;
    /*
     if(feuchte != 0)
     {
     
     AfxMessageBox("feuchte",MB_YESNO,0);
     str.Format(_T("%.5f"),feuchte);
     AfxMessageBox(str,MB_YESNO,0);
     }
     */
    //Praedation
    //praed = praed - praedation;
	//qualitaet = (feuchte * praedation * struktur);
    qualitaet = WURZEL(3, (feuchte * praedation * struktur));
    /*if(qualitaet != 0)
     {
     
     AfxMessageBox("q",MB_YESNO,0);
     str.Format(_T("%.5f"),qualitaet);
     AfxMessageBox(str,MB_YESNO,0);
     }*/

    return qualitaet;
}

//Massnahmezeitpunkt abhängige Habitateignung Q_j^w)
double oekologie::whoehenhabitateignung(
        int gesreproduktionsphase,
        double anspruchhoch,
        double anspruchmittel,
        double anspruchkurz,
        int mv,
        int gruenlandzahl,
        int massnahmemv,
        int abstandm2,
		int abstandm3,
        double besatzdichte,
        double anteilm1,
        double anteilm2,
        double anteilm3,
        bool hoch)
{

    int i = mv;
    int j;
    double hoehe;
    double hanspruch;
    double Q = 0;
    if( besatzdichte < 0.4 || besatzdichte > 60) //es liegt eine Mahd oder eine Koppel/Umtriebsweide vor -> die Fläche hat eine einheitliche Wuchshoehe
    {
        for( i = mv; i < (mv + gesreproduktionsphase); i++)
        {

            double anspruch = 0;
            for( j = 0; j < 10; j++) //Mitteln über 10 Durchläufe damit keine Sprünge vorkommen
            {
                hoehe = wuchshoehe( gruenlandzahl, massnahmemv, abstandm2, abstandm3,i,
                        hoch);
                hanspruch = whoehenanspruch( hoehe, anspruchhoch,
                        anspruchmittel, anspruchkurz);
                anspruch = anspruch + hanspruch;
            }
            anspruch = anspruch / 10;

            Q = Q + (anspruch / gesreproduktionsphase);

        }
    } else // es muss eine Saisionale Standweide oder eine Maehweide vorliegen
    {

        if( abstandm2 == 0) // es ist eine saisonale Standweide oder eine Ganzjahresweide
        {
            double anteilhoehe2, anteilhoehe3, anteilhoehe1;
            for( i = mv; i < (mv + gesreproduktionsphase); i++)
            {
                double anspruch = 0;
                for( j = 0; j < 10; j++) //Mitteln über 10 Durchläufe damit keine Sprünge vorkommen
                {
                    double hoehe1 = wuchshoehe( gruenlandzahl, massnahmemv,
                            abstandm2,abstandm3, i, hoch); //hoehe die erreicht wurde zu diesem Zeitpunkt mit Massnahme bei Ganzjahresweide sollte 1 und 2 gleich sein
                    double hoehe2 = wuchshoehe( gruenlandzahl, 49, 0,0, i, hoch); //ungestoert wachsendes Grass

                    if( hoehe2 < 10) //das Grass ist noch kurz
                    {
                        anteilhoehe2 = 0;
                        anteilhoehe3 = 0;
                        anteilhoehe1 = 1;
                    } else
                    {
                        if( hoehe2 > 30)
                        {
                            if( hoehe1 < hoehe2) //nach Massnahme, es gibt hohes Gras, d.h. alle Anteile sind da
                            {
                                if( i == massnahmemv) // es liegt genau das Massnahmen MV vor-> die Tiere brauchen zwei MV damit sich die Verteilung einstellt
                                {
                                    anteilhoehe2 = 0;
                                    anteilhoehe3 = anteilm3 + anteilm2
                                            + (anteilm1 / 2);
                                    anteilhoehe1 = (anteilm1 / 2);
                                } else
                                {

                                    anteilhoehe2 = anteilm2;
                                    anteilhoehe3 = anteilm3;
                                    anteilhoehe1 = anteilm1;

                                }
                            } else //Nur hohes Grass oder Ganzjahresweide
                            {
                                if( massnahmemv == 1) //Ganzjahresweide alles kommt vor!
                                {
                                    anteilhoehe2 = anteilm2;
                                    anteilhoehe3 = anteilm3;
                                    anteilhoehe1 = anteilm1;
                                } else
                                {
                                    anteilhoehe2 = 0;
                                    anteilhoehe3 = 1;
                                    anteilhoehe1 = 0;
                                }
                            }
                        } else
                        {
                            if( hoehe1 < hoehe2) //nach Massnahme, es gibt noch keine hoches Gras, daher ist der Anteil von Hoch null und mittel entspricht dem Anteil von beiden
                            {
                                if( i == massnahmemv) // es liegt genau das Massnahmen MV vor-> die Tiere brauchen ein MV damit sich die Verteilung einstellt
                                {
                                    anteilhoehe2 = 1;
                                    anteilhoehe3 = 0;
                                    anteilhoehe1 = 0;
                                } else
                                {
                                    anteilhoehe2 = anteilm2 + anteilm3;
                                    anteilhoehe3 = 0;
                                    anteilhoehe1 = anteilm1;

                                }
                            } else //nur mittleres Gras
                            {
                                if( massnahmemv == 1) //Ganzjahresweide 
                                {
                                    anteilhoehe2 = anteilm2 + anteilm3;
                                    anteilhoehe3 = 0;
                                    anteilhoehe1 = anteilm1;
                                } else
                                {
                                    anteilhoehe2 = 1;
                                    anteilhoehe3 = 0;
                                    anteilhoehe1 = 0;
                                }
                            }
                        }
                    }

                    hanspruch = (anteilhoehe1 * anspruchkurz)
                            + (anteilhoehe2 * anspruchmittel)
                            + (anteilhoehe3 * anspruchhoch);
                    anspruch = anspruch + hanspruch;
                }
                anspruch = anspruch / 10;

                Q = Q + (anspruch / gesreproduktionsphase);

            }

        } else //Maehweide
        {
            {
                double anteilhoehe2, anteilhoehe3, anteilhoehe1;
                for( i = mv; i < (mv + gesreproduktionsphase); i++)
                {
                    double anspruch = 0;
                    for( j = 0; j < 10; j++) //Mitteln über 10 Durchläufe damit keine Sprünge vorkommen
                    {
                        double hoehe1 = wuchshoehe( gruenlandzahl, massnahmemv,
                                abstandm2,abstandm3, i, hoch); //hoehe die erreicht wurde zu diesem Zeitpunkt mit Massnahme
                        double hoehe2 = wuchshoehe( gruenlandzahl, massnahmemv,
                                0,0, i, hoch); //nach der Mahd ungestoert wachsendes Grass

                        if( hoehe2 < 10)
                        {
                            anteilhoehe2 = 0;
                            anteilhoehe3 = 0;
                            anteilhoehe1 = 1;
                        } else
                        {
                            if( hoehe2 > 30)
                            {
                                if( hoehe1 < hoehe2) //nach Massnahme, es gibt hohes Gras, d.h. alle Anteile sind da
                                {
                                    if( i == massnahmemv) // es liegt genau das Massnahmen MV vor-> die Tiere brauchen zwei MV damit sich die Verteilung einstellt
                                    {
                                        anteilhoehe2 = anteilm1;
                                        anteilhoehe3 = anteilm3 + anteilm2;
                                        anteilhoehe1 = 0;
                                    } else
                                    {
                                        if( i == massnahmemv + 1)
                                        {
                                            anteilhoehe2 = anteilm2 + anteilm1;
                                            anteilhoehe3 = anteilm3;
                                            anteilhoehe1 = 0;
                                        } else
                                        {
                                            anteilhoehe2 = anteilm2;
                                            anteilhoehe3 = anteilm3;
                                            anteilhoehe1 = anteilm1;
                                        }
                                    }
                                } else //Nur hohes Grass
                                {
                                    anteilhoehe2 = 0;
                                    anteilhoehe3 = 1;
                                    anteilhoehe1 = 0;
                                }
                            } else
                            {
                                if( hoehe1 < hoehe2) //nach Massnahme, es gibt noch keine hoches Gras, daher ist der Anteil von Hoch null und mittel entspricht dem Anteil von beiden
                                {
                                    if( i == massnahmemv) // es liegt genau das Massnahmen MV vor-> die Tiere brauchen ein MV damit sich die Verteilung einstellt
                                    {
                                        anteilhoehe2 = 1;
                                        anteilhoehe3 = 0;
                                        anteilhoehe1 = 0;
                                    } else
                                    {
                                        anteilhoehe2 = anteilm2 + anteilm3;
                                        anteilhoehe3 = 0;
                                        anteilhoehe1 = anteilm1;

                                    }
                                } else //nur mittleres Gras
                                {
                                    anteilhoehe2 = 1;
                                    anteilhoehe3 = 0;
                                    anteilhoehe1 = 0;
                                }
                            }
                        }
                        hanspruch = (anteilhoehe1 * anspruchkurz)
                                + (anteilhoehe2 * anspruchmittel)
                                + (anteilhoehe3 * anspruchhoch);
                        anspruch = anspruch + hanspruch;
                    }
                    anspruch = anspruch / 10;

                    Q = Q + (anspruch / gesreproduktionsphase);

                }

            }
        }
    }

    return Q;

}
//Massnahmezeitpunkt abhängige Habitateignung S_j^w
double oekologie::mortalitaet(
        int mv,
        int massnahmemv,
        int abstandm2,
		int abstandm3,
        int repkritisch,
        int repgesammt)
{
    int m2 = massnahmemv + abstandm2;
    int m3 = massnahmemv + abstandm2 + abstandm3;

    double mort1, mort2, mort3, mortges;
    mort1 = 1;
    mort2 = 1;
    mort3 = 1;

    if( (mv <= massnahmemv) && (massnahmemv < (mv + repkritisch)))
    {
        mort1 = 0;
        return 0;
    }
    if( ((mv + repkritisch) <= massnahmemv)
            && (massnahmemv < (mv + repgesammt)))
    {
        mort1 = (0.5);

    }

    if( abstandm2 != 0)
    {
        if( (mv <= m2) && (m2 < (mv + repkritisch)))
        {
            mort2 = 0;
            return 0;
        }

        if( ((mv + repkritisch) <= m2) && (m2 < (mv + repgesammt)))
        {
            mort2 = (0.5);

        }
    }
	if( abstandm3 != 0)
    {
        if( (mv <= m3) && (m3 < (mv + repkritisch)))
        {
            mort3 = 0;
            return 0;
        }

        if( ((mv + repkritisch) <= m3) && (m3 < (mv + repgesammt)))
        {
            mort3 = (0.5);

        }
    }
    if( ref) //es ist der Referenzschnitt mit 3 Schnitten
    {
        m3 = massnahmemv + 12;
        //for (t = mv; t <= mv+repgesammt; t++)
        //{
        if( (mv <= m3) && (m3 < (mv + repkritisch)))
        {
            mort3 = 0;
            return 0;
        }

        if( ((mv + repkritisch) <= m3) && (m3 < (mv + repgesammt)))
        {
            mort3 = (0.5);

        }
        //}
    }

    //wenn noch kein Wert zurück gegeben wurde ist die Schleife ohne Wert verlassen worden => der Wert ist 1
    mortges = mort1 * mort2 * mort3;

    return mortges;

}
double oekologie::mortalitaet(
        int mv,
        int massnahmemv,
        int abstandm2,
		int abstandm3,
        int repkritisch,
        int repgesammt,
        double faktor,
        double viehanzahl)
{

    int t, w;
    double P = 1;
    if( faktor > 0.001)
    {
        if( massnahmemv < mv + repkritisch)
        {
            double mortfaktor = faktor * viehanzahl;
            for( w = massnahmemv; w <= mv + repgesammt; w++)
            {

                P = P * exp( -mortfaktor);
            }
            return P;
        } else
            return 1;
    } else
        return 1;

}

double oekologie::eiablagew(
        int mv,
        int mvletzteersatzbrut,
        int massnahmemv,
        int abstandm2,
		int abstandm3,
        double eiablagewahrmv,
        double eiablagewahrmassnahmemv,
        double eiablagew2,
		double eiablagew3,
        double ersatzbrutwahr,
        int verfahren_nr,
        bool tritt)
{
    double eiablage;
    int m2 = massnahmemv + abstandm2;
	int m3 = massnahmemv + abstandm2 + abstandm3;
    if( tritt)// tritt ist immer true für Mahd und Hutung
    {
        
            if( (mv == (massnahmemv + 1)) || (mv == (m2 + 1))|| (mv == (m3 + 1)))
            {
                if( eiablagewahrmassnahmemv > 0.0001)
				{

					if( mv == massnahmemv + 1)
					{
						if( (massnahmemv <= mvletzteersatzbrut))
						{
							eiablage = eiablagewahrmv
									+ (eiablagewahrmassnahmemv * ersatzbrutwahr);
							return eiablage;
						}
					}
				}else
                    return eiablagewahrmv;

                if( verfahren_nr != 7 || tritt)
                {
					if( eiablagew2> 0.0001)
					{
						if( abstandm2 != 0)
						{
							if( mv == (m2 + 1))
							{
								if( m2 <= mvletzteersatzbrut)
								{
									eiablage = eiablagewahrmv
											+ (eiablagew2 * ersatzbrutwahr);
									return eiablage;
								}
							}
						}
					}else
						 return eiablagewahrmv;

					if( eiablagew3> 0.0001)
					{
						if( abstandm3 != 0)
						{
							if( mv == (m3 + 1))
							{
								if( m3 <= mvletzteersatzbrut)
								{
									eiablage = eiablagewahrmv
											+ (eiablagew3 * ersatzbrutwahr);
									return eiablage;
								}
							}
						}
					}else
						return eiablagewahrmv;

				} else
                    return eiablagewahrmv;

            } else
                return eiablagewahrmv;
        } else
            return eiablagewahrmv;
 

}

double oekologie::habitatqualitaet(
        art* art_j,
        pixel pixel_i,
        massnahme massnahme_t,
        vector< gruenland*> gruenlandliste,
        double& faktor)
{
    int gruenlandzahl = pixel_i.get_gruenlandzahl();
    double anspruchwasser = art_j->get_anspruch_wasser();
    double anspruchsiedlung = art_j->get_anspruch_siedlung();
    double anspruchwald = art_j->get_anspruch_wald();
    double anspruchkurz = art_j->get_hoehe_kurz();
    double anspruchmittel = art_j->get_hoehe_mittel();
    double anspruchhoch = art_j->get_hoehe_hoch();
    double anspruchfeucht = art_j->get_feuchte_feucht();
    double anspruchfrisch = art_j->get_feuchte_frisch();
    double anspruchtrocken = art_j->get_feuchte_trocken();
    int zweitegeneration = art_j->get_zweitegeneration();
    int zweitegenerationende = art_j->get_zweitegeneration_ende();
    int gesamt2 = art_j->get_reproduktion_gesammt2();
    int nummer = art_j->get_Lebensraumnr();
    CString name_deutsch = art_j->get_m_name();
    CString gruppe = art_j->get_gruppe();
    double unabhaengigequal;
    double gruenlandqual = 0;
    bool streifenmahd = massnahme_t.streifenmahd;
    vector< gruenland*> eliste;
    vector< gruenland*>::iterator j;
    bool tritt = false;
    if( massnahme_t.grossvieheinheit < 0.4 || massnahme_t.grossvieheinheit > 60)//für Mahd und Hutung ist der Tritt immer true unabhängig von Tierart
        tritt = true;
    if( art_j->get_trittmortalitaettyp() != 0)
        tritt = true;

    if( massnahme_t.verfahren_nr == 1)
        ref = true;
    else
        ref = false;

    int i;
    double gesammtqualitaet = 0;
    double gesammtqualitaet2 = 0;

    bool hochp;
    int ph = pixel_i.get_hoehenlage();
    if( ph != 0)
        hochp = true;
    else
        hochp = false;

    if( gruppe == "Lebensraum")
    {

        for( j = gruenlandliste.begin(); j != gruenlandliste.end(); j++)
        {

            if( ((*(*j)).name_deutsch == name_deutsch)
                    && ((*(*j)).hoch == hochp))
                gesammtqualitaet = 1;
        }

   

        if( gesammtqualitaet == 1)
        {
			int z = 0;
			double  feuchte = 0;
			//Berechnung von F
			if( pixel_i.get_feuchte_feucht() > 0)
			{
				z = z + 1;
				feuchte = pixel_i.get_feuchte_feucht() * anspruchfeucht;

			}

			if( pixel_i.get_feuchte_mittel() > 0)
			{
				z = z + 1;
				feuchte = feuchte + (pixel_i.get_feuchte_mittel() * anspruchfrisch);
			}

			if(  pixel_i.get_feuchte_trocken() > 0)
			{
				z = z + 1;
				feuchte = feuchte + ( pixel_i.get_feuchte_trocken() * anspruchtrocken);
			}

			feuchte = feuchte / z;

			feuchte = WURZEL(2,feuchte);
            

			gesammtqualitaet = feuchte;

        }

    } else
    {

        if( (gruppe == "Schmetterling") && (zweitegeneration != 0))
        {
            double sum1 = 0;
            double sum2 = 0;
            for( i = 1; i < zweitegeneration; i++)
            {
                sum1 = art_j->get_monatsviertel( i) + sum1;
            }
            for( i = zweitegeneration; i < zweitegenerationende; i++)
            {
                sum2 = art_j->get_monatsviertel( i) + sum2;
            }
            for( i = 1; i < zweitegeneration; i++)
            {
                double ew = 0; //angepasste Eiablagewahrscheinlichkeit
                if( (art_j->get_monatsviertel( i)) != 0)
                    ew = ( (art_j->get_monatsviertel( i)) / sum1);
                double eiablage = eiablagew( i,
                        art_j->get_monatsviertel_ersatzbrut(),
                        massnahme_t.mv1massnahme, massnahme_t.abstand2massnahme,massnahme_t.abstand3massnahme,
                        ew, art_j->get_monatsviertel( massnahme_t.mv1massnahme),
                        art_j->get_monatsviertel(
                                massnahme_t.mv1massnahme
                                        + massnahme_t.abstand2massnahme),
						art_j->get_monatsviertel(
									massnahme_t.mv1massnahme + massnahme_t.abstand2massnahme
									+ massnahme_t.abstand3massnahme),
                        art_j->get_ersatzbrut_erfolg(),
                        massnahme_t.verfahren_nr, tritt);
                double mort, mort2;
                if( massnahme_t.tierart == 0
                        || massnahme_t.grossvieheinheit > 60)
                    mort = mortalitaet( i, massnahme_t.mv1massnahme,
                            massnahme_t.abstand2massnahme,massnahme_t.abstand3massnahme,
                            art_j->get_reproduktion_kritisch(),
                            art_j->get_reproduktion_gesammt());
                else
                {
                    if( massnahme_t.verfahren_nr == 7 && massnahme_t.grossvieheinheit < 60)
                    {
                       
						mort = mortalitaet( i, massnahme_t.mv1massnahme, 0,0,
                                art_j->get_reproduktion_kritisch(),
                                art_j->get_reproduktion_gesammt());
                        if( art_j->get_trittmortalitaettyp() != 0)
                            mort2 = mortalitaet( i,
                                    massnahme_t.mv1massnahme
                                            + massnahme_t.abstand2massnahme,
                                    massnahme_t.abstand2massnahme,0,
                                    art_j->get_reproduktion_kritisch(),
                                    art_j->get_reproduktion_gesammt(), faktor,
                                    massnahme_t.grossvieheinheit);
                        else
                            mort2 = 1;
                        mort = mort * mort2;
                    } else
                    {
                        if( art_j->get_trittmortalitaettyp() != 0)
                            mort = mortalitaet( i, massnahme_t.mv1massnahme,
                                    massnahme_t.abstand2massnahme,massnahme_t.abstand3massnahme,
                                    art_j->get_reproduktion_kritisch(),
                                    art_j->get_reproduktion_gesammt(), faktor,
                                    massnahme_t.grossvieheinheit);
                        else
                            mort = 1;
                    }

                }
                double habitateignung = whoehenhabitateignung(
                        art_j->get_reproduktion_gesammt(), anspruchhoch,
                        anspruchmittel, anspruchkurz, i, gruenlandzahl,
                        massnahme_t.mv1massnahme, massnahme_t.abstand2massnahme,
						massnahme_t.abstand3massnahme,
                        massnahme_t.grossvieheinheit,
                        massnahme_t.hoehenanteil_niedrig,
                        massnahme_t.hoehenanteil_mittel,
                        massnahme_t.hoehenanteil_hoch, hochp);

                gesammtqualitaet = gesammtqualitaet
                        + (eiablage * mort * habitateignung);
            }
            for( i = zweitegeneration; i < (zweitegenerationende); i++)
            {
                int r = i;
                double ew = 0; //angepasste Eiablagewahrscheinlichkeit
                if( (art_j->get_monatsviertel( r)) != 0)
                    ew = ( (art_j->get_monatsviertel( r)) / sum2);
                double eiablage = eiablagew( r,
                        art_j->get_monatsviertel_ersatzbrut(),
                        massnahme_t.mv1massnahme, massnahme_t.abstand2massnahme,massnahme_t.abstand3massnahme,
                        ew, art_j->get_monatsviertel( massnahme_t.mv1massnahme),
                        art_j->get_monatsviertel(
                                massnahme_t.mv1massnahme
                                        + massnahme_t.abstand2massnahme),
						art_j->get_monatsviertel(
                                massnahme_t.mv1massnahme  + massnahme_t.abstand2massnahme
                                        + massnahme_t.abstand3massnahme),
                        art_j->get_ersatzbrut_erfolg(),
                        massnahme_t.verfahren_nr, tritt);
                double mort, mort2;
                if( massnahme_t.tierart == 0
                        || massnahme_t.grossvieheinheit > 60)
                    mort = mortalitaet( i, massnahme_t.mv1massnahme,
                            massnahme_t.abstand2massnahme, massnahme_t.abstand3massnahme,
                            art_j->get_reproduktion_kritisch(),
                            art_j->get_reproduktion_gesammt());

                else
                {
                    if( massnahme_t.verfahren_nr == 7 && massnahme_t.grossvieheinheit < 60)
                    {
                        mort = mortalitaet( i, massnahme_t.mv1massnahme, 0,0,
                                art_j->get_reproduktion_kritisch(),
                                art_j->get_reproduktion_gesammt());
                        if( art_j->get_trittmortalitaettyp() != 0)
                            mort2 = mortalitaet( i,
                                    massnahme_t.mv1massnahme
                                            + massnahme_t.abstand2massnahme,
                                    massnahme_t.abstand2massnahme,0,
                                    art_j->get_reproduktion_kritisch(),
                                    art_j->get_reproduktion_gesammt(), faktor,
                                    massnahme_t.grossvieheinheit);
                        else
                            mort2 = 1;
                        mort = mort * mort2;
                    } else
                    {
                        if( art_j->get_trittmortalitaettyp() != 0)
                            mort = mortalitaet( i, massnahme_t.mv1massnahme,
                                    massnahme_t.abstand2massnahme,0,
                                    art_j->get_reproduktion_kritisch(),
                                    art_j->get_reproduktion_gesammt(), faktor,
                                    massnahme_t.grossvieheinheit);
                        else
                            mort = 1;
                    }
                }
                double habitateignung = whoehenhabitateignung(
                        art_j->get_reproduktion_gesammt2(), anspruchhoch,
                        anspruchmittel, anspruchkurz, r, gruenlandzahl,
                        massnahme_t.mv1massnahme, massnahme_t.abstand2massnahme,massnahme_t.abstand3massnahme,
                        massnahme_t.grossvieheinheit,
                        massnahme_t.hoehenanteil_niedrig,
                        massnahme_t.hoehenanteil_mittel,
                        massnahme_t.hoehenanteil_hoch, hochp);
                gesammtqualitaet2 = gesammtqualitaet2
                        + (eiablage * mort * habitateignung);

            }

            gesammtqualitaet = gesammtqualitaet * gesammtqualitaet2;

        } else
        {
            for( i = 1; i < 48; i++)
            //for( i = 1;i<48; i++)
            {
                double eiablage = eiablagew( i,
                        art_j->get_monatsviertel_ersatzbrut(),
                        massnahme_t.mv1massnahme, massnahme_t.abstand2massnahme, massnahme_t.abstand3massnahme,
                        art_j->get_monatsviertel( i),
                        art_j->get_monatsviertel( massnahme_t.mv1massnahme),
                        art_j->get_monatsviertel(massnahme_t.mv1massnahme
                                        + massnahme_t.abstand2massnahme),
						art_j->get_monatsviertel(
                               ( massnahme_t.mv1massnahme + massnahme_t.abstand2massnahme
                                        + massnahme_t.abstand3massnahme)),
                        art_j->get_ersatzbrut_erfolg(),
                        massnahme_t.verfahren_nr, tritt);
                double mort, mort2;
                if( massnahme_t.tierart == 0
                        || massnahme_t.grossvieheinheit > 60)
                {
                    mort = mortalitaet( i, massnahme_t.mv1massnahme,
                            massnahme_t.abstand2massnahme,massnahme_t.abstand3massnahme,
                            art_j->get_reproduktion_kritisch(),
                            art_j->get_reproduktion_gesammt());
                    if( streifenmahd == 1 && mort < 0.4)
                        mort = 0.25;
                    if( streifenmahd == 1 && (mort > 0.4 && mort < 0.9))
                        mort = 0.75;
                } else
                {
                    if( massnahme_t.verfahren_nr == 7 && massnahme_t.grossvieheinheit < 60)
                    {
                        mort = mortalitaet( i, massnahme_t.mv1massnahme, 0,0,
                                art_j->get_reproduktion_kritisch(),
                                art_j->get_reproduktion_gesammt());
                        if( art_j->get_trittmortalitaettyp() != 0)
                            mort2 = mortalitaet( i,
                                    massnahme_t.mv1massnahme
                                            + massnahme_t.abstand2massnahme,
                                    massnahme_t.abstand2massnahme,0,
                                    art_j->get_reproduktion_kritisch(),
                                    art_j->get_reproduktion_gesammt(), faktor,
                                    massnahme_t.grossvieheinheit);
                        else
                            mort2 = 1;
                        mort = mort * mort2;
                    } else
                    {
                        if( art_j->get_trittmortalitaettyp() != 0)
                            mort = mortalitaet( i, massnahme_t.mv1massnahme,
                                    massnahme_t.abstand2massnahme,massnahme_t.abstand3massnahme,
                                    art_j->get_reproduktion_kritisch(),
                                    art_j->get_reproduktion_gesammt(), faktor,
                                    massnahme_t.grossvieheinheit);
                        else
                            mort = 1;
                    }
                }
                double habitateignung = whoehenhabitateignung(
                        art_j->get_reproduktion_gesammt(), anspruchhoch,
                        anspruchmittel, anspruchkurz, i, gruenlandzahl,
                        massnahme_t.mv1massnahme, massnahme_t.abstand2massnahme,
						massnahme_t.abstand3massnahme,
                        massnahme_t.grossvieheinheit,
                        massnahme_t.hoehenanteil_niedrig,
                        massnahme_t.hoehenanteil_mittel,
                        massnahme_t.hoehenanteil_hoch, hochp);

                gesammtqualitaet = gesammtqualitaet
                        + (eiablage * mort * habitateignung);

            }
        }
		}
        /*
         CString str;
         AfxMessageBox("Pixelfeuchteaufruf",MB_YESNO,0);
         str.Format(_T("%.5f"),pixel_i.get_feuchte_feucht());
         AfxMessageBox(str,MB_YESNO,0);
         AfxMessageBox("Pixelmittelaufruf",MB_YESNO,0);
         str.Format(_T("%.5f"),pixel_i.get_feuchte_mittel());
         AfxMessageBox(str,MB_YESNO,0);
         AfxMessageBox("Pixeltrockenaufruf",MB_YESNO,0);
         str.Format(_T("%.5f"),pixel_i.get_feuchte_trocken());
         AfxMessageBox(str,MB_YESNO,0);
    */

       
        /*if(unabhaengigequal != 0)
         {
         CString str;
         AfxMessageBox("unabh",MB_YESNO,0);
         str.Format(_T("%.5f"),unabhaengigequal);
         AfxMessageBox(str,MB_YESNO,0);
         }*/
//AfxMessageBox("bin hier 1",MB_YESNO,0);
        // der Gruenlandparameter G_j^m spielt nur für die Schmetterlinge eine Rolle, ist also für Vögel immer 1!
        if( gruppe == "Schmetterling")
        {
            bool hochp;
            int ph = pixel_i.get_hoehenlage();
            if( ph != 0)
                hochp = 1;
            else
                hochp = 0;
            bool mager;
            if( gruenlandzahl < 35)
                mager = 1;
            else
                mager = 0;
            vector< int>::iterator git;
            //eliste = gruenlandabhaengigequalitaet(massnahme_t.massnahmeID,pixel_i.get_hoehenlage(), gruenlandliste);
            //for schleife um die Gruenlandtypen mit den Artspezifischen Typen abzugleichen
            for( j = gruenlandliste.begin(); j != gruenlandliste.end(); j++)
            {
                //AfxMessageBox("bin hier",MB_YESNO,0);

                for( git = art_j->gruenlandID.begin();
                        git != art_j->gruenlandID.end(); git++)
                {
                    if( ((*(*j)).gruenlandID == *git) && ((*(*j)).hoch == hochp)
                            && ((*(*j)).mager == mager))
                    {
                        gruenlandqual = 1;
                        break;
                    }
                }
                if( gruenlandqual == 1)
                    break;
            }
			int z = 0;
			double  feuchte = 0;
			//Berechnung von F
			if( pixel_i.get_feuchte_feucht() > 0)
			{
				z = z + 1;
				feuchte = pixel_i.get_feuchte_feucht() * anspruchfeucht;

			}

			if( pixel_i.get_feuchte_mittel() > 0)
			{
				z = z + 1;
				feuchte = feuchte + (pixel_i.get_feuchte_mittel() * anspruchfrisch);
			}

			if(  pixel_i.get_feuchte_trocken() > 0)
			{
				z = z + 1;
				feuchte = feuchte + ( pixel_i.get_feuchte_trocken() * anspruchtrocken);
			}

			feuchte = feuchte / z;
		
			if((gruenlandqual > 0)&& ( feuchte > 0))
			{

				feuchte = WURZEL(2,feuchte);
			}
			else
				feuchte = 0;
			
			gesammtqualitaet = gesammtqualitaet * feuchte;

        } else
        {
	
			if( gruppe == "Vogel")
			{
				unabhaengigequal = massnahmeunabhaengigequalitaet( pixel_i.get_wald(),
                pixel_i.get_wasser(), pixel_i.get_siedlung(), anspruchwald,
                anspruchsiedlung, anspruchwasser, pixel_i.get_feuchte_feucht(),
                pixel_i.get_feuchte_mittel(), pixel_i.get_feuchte_trocken(),
                anspruchfeucht, anspruchfrisch, anspruchtrocken,
                art_j->praedation);

				gesammtqualitaet = unabhaengigequal * gesammtqualitaet;
			}
		}
		
	
    for( j = eliste.begin(); j != eliste.end(); j++)
    {
        delete *(j);
    }

    return gesammtqualitaet;
}

vector< gruenland*> oekologie::gruenlandabhaengigequalitaet(
        int massnahmeID,
        int pixel_hoehe,
        vector< gruenland*> gruenlandliste,
        bool weide)
{
    list< int> gruenlandID;
    list< int>::iterator i;
    vector< gruenland*>::iterator j;
    vector< gruenland*> eliste;
    int ID1;
    bool hochp, qualitaet;

    if( pixel_hoehe != 0)
        hochp = 1;
    else
        hochp = 0;

    datenbank daten;

    gruenlandID = daten.getgruenland_for_massnahme_from_database( massnahmeID,
            weide);

    for( i = gruenlandID.begin(); i != gruenlandID.end(); i++)
    {
        ID1 = *(i);
        for( j = gruenlandliste.begin(); j != gruenlandliste.end(); j++)
        {
            if( ID1 == ((*(*j)).gruenlandID))
            {

                if( (*(*j)).hoch == hochp)
                    eliste.push_back( *(j));

            }

        }
    }
    return eliste;

}