#include "StdAfx.h"
#include "modell.h"
#include "pixel.h"
#include "oekologie.h"
#include "massnahme.h"
#include "kosten.h"
#include "matrix.h"
#include "datenbank.h"
#include "variablekosten.h"
#include "verfahren_ertrag.h"
#include "wuchshoehe.h"
#include <time.h>
#include <limits> 

//hier werden ökonomische und ökologische moelierung zusammengeführt
modell::modell( void)
{
}

modell::~modell( void)
{
}
bool myfunction( ergebnis::mq mq1, ergebnis::mq mq2)
{
    return (mq1.gewinn > mq2.gewinn);
}
bool sortfunction( modell::gruenlandqualitaet g1, modell::gruenlandqualitaet g2)
{
    return (g1.gruenlandID > g2.gruenlandID);
}
ergebnis* modell::create_oekologiemodell( art* artdata, int bundeslandID)
{
    ergebnis* er;
    er = new ergebnis;
    datenbank daten;
    oekologie oeko;
    //die Massnahmen werden aus der Datenbank geholt
    int massnahmenanzahl, i;

    massnahme** massnahmenliste = daten.returnmassnahmen( massnahmenanzahl);
    //AfxMessageBox("komme bis hinter die Massnahmenliste",MB_YESNO,0);
    vector< gruenland*> gliste;
    //list<gruenland*> eliste;
    vector< gruenland*>::iterator j;
    int anzahlgruenland;
    gliste = daten.returngruenland( anzahlgruenland);
    //AfxMessageBox("komme bis hinter die Gruenlandliste",MB_YESNO,0);
    double qualitaet;
    int n, m; //Zaehler um die nm Matrix zu durchlaufen

    pixel*** neue_matrix;
    //die Matrix für das Bundesland Sachsen wird erstellt mit 677 zeilen und 888 Spalten
    int zeilen, spalten;
    daten.get_matrix_referenz( zeilen, spalten, 1);
    matrix mat;
    neue_matrix = mat.create_pixel_matrix( zeilen, spalten, bundeslandID);

    //für ein pixel werden alle massnahmen durchlaufen und sowohl die qualität erzeugt als auch das sich
    // resultierende gruenland -> in die drei ergebnis vecotren werden die Qualität, das Gruenland und 
    // die Massnahme geschoben

    double u, g, l;

    for( n = 0; n < zeilen; n++)
    {
        for( m = 0; m < spalten; m++)
        {
            pixel* pix = neue_matrix[ n][ m];
            //pixel* pix = neue_matrix[2][268];
            CString str;
            int ref = pix->get_gruenlandzahl();

            /*
             str.Format(_T("%d"),ref);
             AfxMessageBox(str,MB_YESNO,0);
             AfxMessageBox(artdata->get_m_name_latein(),MB_YESNO,0);*/
            int anzahl;

            if( ref != 0)
            {
                if( (pix->get_feuchte_feucht() != 0)
                        || (pix->get_feuchte_mittel() != 0)
                        || (pix->get_feuchte_trocken() != 0))
                {
                    for( i = 0; i < massnahmenanzahl; i++)
                    {

                        double faktor = daten.get_trittmortalitaet(
                                (*(massnahmenliste[ i])).tierart,
                                artdata->get_trittmortalitaettyp());
                        qualitaet = oeko.habitatqualitaet( artdata, (*pix),
                                *(massnahmenliste[ i]), gliste, faktor);
                        str.Format( _T( "%.5f"), qualitaet);
                        //ergebDlg->m_liste.AddString(str);
                        //AfxMessageBox(str,MB_YESNO,0);
                        //er->gruenlandliste.push_back(eliste);
                        er->massnahmen.push_back( *(massnahmenliste[ i]));
                        er->qualitaet.push_back( qualitaet);
                        er->lqualitaet.push_back( l); //gruenlandqual
                        er->mqualitaet.push_back( g); //gesammtqualitaet
                        er->unqualitaet.push_back( u); //unabhaengigequal

                    }

                    anzahl++;
                }
            }
        }
    }
    return er;
    //aufräumen nicht vergessen!
    for( i = 0; i < massnahmenanzahl; i++)
    {
        delete massnahmenliste[ i];
    }
    delete massnahmenliste;
    for( j = gliste.begin(); j != gliste.end(); j++)
    {
        delete *(j);
    }

    mat.delete_pixel_matrix( neue_matrix, zeilen, spalten);

}
ergebnis*** modell::create_oekologiemodell(
        vector< art*> artlist,
        vector< massnahme> mliste,
        double minqualitaet,
        int bundeslandID,
        bool hoch,
        bool egal)
{

    datenbank daten;
    oekologie oeko;
    //die Massnahmen sind vorgegeben
    //Als erstes die Gruenlandzahlen Grenzen fuer die 4 Ertragsklassen holen!!!
    int gzniedrigmax, gzmittelmax, gzhochmax, gzsehrhochmax;
    double besatzniedrig, besatzmittel, besatzhoch, besatzsehrhoch;
    daten.get_ertrags_besatz_grenzen( gzniedrigmax, gzmittelmax, gzhochmax,
            gzsehrhochmax, besatzniedrig, besatzmittel, besatzhoch,
            besatzsehrhoch);
	daten.get_bundesland(bundeslandID, oeko.start, oeko.niedrig, oeko.mittel);
    wuchshoehe whoehe1, whoehe2, whoehe3; //Die Wuchshoehen die sich bei Beweidung einstellen fuer die drei Wuchsklassen
    whoehe1 = whoehe1.get_wuchshoehe_from_database( 1);
    whoehe2 = whoehe2.get_wuchshoehe_from_database( 2);
    whoehe3 = whoehe3.get_wuchshoehe_from_database( 3);

    verfahren_ertrag v1, v2, v3, v4, v5, v6, v7,v8; //Es werden genau 8 Verfahren betrachtet
    v1 = v1.get_verfahren_kosten_from_database( 1);
    v2 = v2.get_verfahren_kosten_from_database( 2);
    v3 = v3.get_verfahren_kosten_from_database( 3);
    v4 = v4.get_verfahren_kosten_from_database( 4);
    v5 = v5.get_verfahren_kosten_from_database( 5);
    v6 = v6.get_verfahren_kosten_from_database( 6);
    v7 = v7.get_verfahren_kosten_from_database( 7);
	v8 = v8.get_verfahren_kosten_from_database( 8);
    //Fuer jedes Verfahren werden anhand der geladenen Daten die Ertragswerte fuer die einzelnen 
    //Gruenlandzahlen berechnet und in einen Vector gespeichert-> genau 100 Werte, der Vector hat groesse 101
    vector< double> ertragv1;
    v1.berechne_gzertrag( v1.gruenlandzahl1, v1.gruenlandzahl2,
            v1.gruenlandzahl3, v1.gruenlandzahl4, v1.ertrag1, v1.ertrag2,
            v1.ertrag3, v1.ertrag4, ertragv1);
    vector< double> ertragv2;
    v2.berechne_gzertrag( v2.gruenlandzahl1, v2.gruenlandzahl2,
            v2.gruenlandzahl3, v2.gruenlandzahl4, v2.ertrag1, v2.ertrag2,
            v2.ertrag3, v2.ertrag4, ertragv2);
    vector< double> ertragv3;
    v3.berechne_gzertrag( v3.gruenlandzahl1, v3.gruenlandzahl2,
            v3.gruenlandzahl3, v3.gruenlandzahl4, v3.ertrag1, v3.ertrag2,
            v3.ertrag3, v3.ertrag4, ertragv3);
    vector< double> ertragv4;
    v4.berechne_gzertrag( v4.gruenlandzahl1, v4.gruenlandzahl2,
            v4.gruenlandzahl3, v4.gruenlandzahl4, v4.ertrag1, v4.ertrag2,
            v4.ertrag3, v4.ertrag4, ertragv4);
    vector< double> ertragv5;
    v5.berechne_gzertrag( v5.gruenlandzahl1, v5.gruenlandzahl2,
            v5.gruenlandzahl3, v5.gruenlandzahl4, v5.ertrag1, v5.ertrag2,
            v5.ertrag3, v5.ertrag4, ertragv5);
    vector< double> ertragv6;
    v6.berechne_gzertrag( v6.gruenlandzahl1, v6.gruenlandzahl2,
            v6.gruenlandzahl3, v6.gruenlandzahl4, v6.ertrag1, v6.ertrag2,
            v6.ertrag3, v6.ertrag4, ertragv6);
    vector< double> ertragv7;
    v7.berechne_gzertrag( v7.gruenlandzahl1, v7.gruenlandzahl2,
            v7.gruenlandzahl3, v7.gruenlandzahl4, v7.ertrag1, v7.ertrag2,
            v7.ertrag3, v7.ertrag4, ertragv7);
	vector< double> ertragv8;
    v8.berechne_gzertrag( v8.gruenlandzahl1, v8.gruenlandzahl2,
            v8.gruenlandzahl3, v8.gruenlandzahl4, v8.ertrag1, v8.ertrag2,
            v8.ertrag3, v8.ertrag4, ertragv8);

    // Fuer die Referenzverfahren koennen nun schon anhand der Ertraege die Energiewerte fuer jede Gruenlandzahl berechnet werden
    vector< double> refenergie1;
    v1.berechne_referenz( ertragv1, 1, refenergie1); //der 3Schnitt
    vector< double> refenergie4;
    v4.berechne_referenz( ertragv4, 4, refenergie4); //die intensive Weide
    vector< double> refenergie6;
    v6.berechne_referenz( ertragv6, 6, refenergie6); //die intensive Maehweide
    vector< double> refenergie5;
    v5.berechne_referenz( ertragv5, 4, refenergie5); //die extensive Weide
    vector< double> refenergie7;
    v7.berechne_referenz( ertragv7, 6, refenergie7); //die extensive Maehweide
	
    vector< double>::iterator vi;
    /*AfxMessageBox("ertrag",MB_YESNO,0);
     int hel = 0;
     for(vi = ertragv2.begin(); vi != ertragv2.end(); vi++)
     {
     CString str;
     if (hel == 13 || hel == 40)
     {
     str.Format(_T("%.2f"),*vi);
     AfxMessageBox(str,MB_YESNO,0);
     }
     hel++;
     }

     AfxMessageBox("Referenzertrag",MB_YESNO,0);
     hel = 0;
     for(vi = refenergie1.begin(); vi != refenergie1.end(); vi++)
     {
     CString str;
     if (hel == 13 || hel == 40)
     {
     str.Format(_T("%.2f"),*vi);
     AfxMessageBox(str,MB_YESNO,0);
     }
     hel++;
     }*/

    CString str;

    //Fuer jedes Verfahren die variablen Kosten aus der Datenbank geholt und jeweils in einem Vector fuer alle Gruenlandzahlen
    //gespeichert auch wenn fuer die 4 Leistungsklassen der Wert gleich ist : solange maehweide noch nicht drinn ist nur 5 Verfahren!!!
    variablekosten vark1, vark2, vark3, vark4, vark5, vark6, vark7, vark8;
    vector< variablekosten> vk1, vk2, vk3, vk4, vk5, vk6, vk7, vk8;
    vark1.get_kosten_from_database( 1, vk1);
    str.Format( _T( "%.5f"), vk1[ 0].saatgutkosten);
    //AfxMessageBox(str,MB_YESNO,0);	
    str.Format( _T( "%.5f"), vk1[ 0].diesel);
    //AfxMessageBox(str,MB_YESNO,0);	

    vark2.get_kosten_from_database( 2, vk2);
    vark3.get_kosten_from_database( 3, vk3);
    vark4.get_kosten_from_database( 4, vk4);
    vark5.get_kosten_from_database( 5, vk5);
    vark6.get_kosten_from_database( 6, vk6);
    vark7.get_kosten_from_database( 7, vk7);
	vark8.get_kosten_from_database( 8, vk8);

    vector< double> varkosten10, varkosten11; //wird fuer jede Gruenlandzahl die variablen Kosten des ersten Verfahrens  beinhalten
    double v110, v111, v120, v121, v130, v131, v140, v141;
    //v110 = vk1[0].berechne_variablekosten(0);//jeweils mit Duengung->1 und ohne Duengung ->0

    v111 = vk1[ 0].berechne_variablekosten( 1);

    //v120 = vk1[1].berechne_variablekosten(0);

    v121 = vk1[ 1].berechne_variablekosten( 1);

    //v130 = vk1[2].berechne_variablekosten(0);

    v131 = vk1[ 2].berechne_variablekosten( 1);

//	v140 = vk1[3].berechne_variablekosten(0);

    v141 = vk1[ 3].berechne_variablekosten( 1);

    vector< double> varkosten20, varkosten21;
    double v210, v211, v220, v221, v230, v231, v240, v241;
    v210 = vk2[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v211 = vk2[ 0].berechne_variablekosten( 1);
    v220 = vk2[ 1].berechne_variablekosten( 0);
    v221 = vk2[ 1].berechne_variablekosten( 1);
    v230 = vk2[ 2].berechne_variablekosten( 0);
    v231 = vk2[ 2].berechne_variablekosten( 1);
    v240 = vk2[ 3].berechne_variablekosten( 0);
    v241 = vk2[ 3].berechne_variablekosten( 1);
    vector< double> varkosten30, varkosten31;
    double v310, v311, v320, v321, v330, v331, v340, v341;
    v310 = vk3[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v311 = vk3[ 0].berechne_variablekosten( 1);
    v320 = vk3[ 1].berechne_variablekosten( 0);
    v321 = vk3[ 1].berechne_variablekosten( 1);
    v330 = vk3[ 2].berechne_variablekosten( 0);
    v331 = vk3[ 2].berechne_variablekosten( 1);
    v340 = vk3[ 3].berechne_variablekosten( 0);
    v341 = vk3[ 3].berechne_variablekosten( 1);
    vector< double> varkosten40, varkosten41;
    double v410, v411, v420, v421, v430, v431, v440, v441;
    //v410 = vk4[0].berechne_variablekosten(0);//jeweils mit Duengung->1 und ohne Duengung ->0
    v411 = vk4[ 0].berechne_variablekosten( 1);
    //v420 = vk4[1].berechne_variablekosten(0);
    v421 = vk4[ 1].berechne_variablekosten( 1);
    //v430 = vk4[2].berechne_variablekosten(0);
    v431 = vk4[ 2].berechne_variablekosten( 1);
    //v440 = vk4[3].berechne_variablekosten(0);
    v441 = vk4[ 3].berechne_variablekosten( 1);
    vector< double> varkosten50, varkosten51;
    double v510, v511, v520, v521, v530, v531, v540, v541;
    v510 = vk5[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0

    v511 = vk5[ 0].berechne_variablekosten( 1);

    v520 = vk5[ 1].berechne_variablekosten( 0);

    v521 = vk5[ 1].berechne_variablekosten( 1);

    v530 = vk5[ 2].berechne_variablekosten( 0);

    v531 = vk5[ 2].berechne_variablekosten( 1);

    v540 = vk5[ 3].berechne_variablekosten( 0);

    v541 = vk5[ 3].berechne_variablekosten( 1);

    vector< double> varkosten60, varkosten61;
    double v610, v611, v620, v621, v630, v631, v640, v641;
    //v610 = vk6[0].berechne_variablekosten(0);//jeweils mit Duengung->1 und ohne Duengung ->0
    v611 = vk6[ 0].berechne_variablekosten( 1);
    //v620 = vk6[1].berechne_variablekosten(0);
    v621 = vk6[ 1].berechne_variablekosten( 1);
    //v630 = vk6[2].berechne_variablekosten(0);
    v631 = vk6[ 2].berechne_variablekosten( 1);
    //v640 = vk6[3].berechne_variablekosten(0);
    v641 = vk6[ 3].berechne_variablekosten( 1);
    vector< double> varkosten70, varkosten71;
    double v710, v711, v720, v721, v730, v731, v740, v741;
    v710 = vk7[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v711 = vk7[ 0].berechne_variablekosten( 1);
    v720 = vk7[ 1].berechne_variablekosten( 0);
    v721 = vk7[ 1].berechne_variablekosten( 1);
    v730 = vk7[ 2].berechne_variablekosten( 0);
    v731 = vk7[ 2].berechne_variablekosten( 1);
    v740 = vk7[ 3].berechne_variablekosten( 0);
    v741 = vk7[ 3].berechne_variablekosten( 1);
	vector< double> varkosten80, varkosten81;
    double v810, v811, v820, v821, v830, v831, v840, v841;
    v810 = vk8[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v811 = vk8[ 0].berechne_variablekosten( 1);
    v820 = vk8[ 1].berechne_variablekosten( 0);
    v821 = vk8[ 1].berechne_variablekosten( 1);
    v830 = vk8[ 2].berechne_variablekosten( 0);
    v831 = vk8[ 2].berechne_variablekosten( 1);
    v840 = vk8[ 3].berechne_variablekosten( 0);
    v841 = vk8[ 3].berechne_variablekosten( 1);
    int h;
    for( h = 0; h < gzniedrigmax + 1; h++)
    {
        //varkosten10.push_back(v110);
        varkosten11.push_back( v111);
        varkosten20.push_back( v210);
        varkosten21.push_back( v211);
        varkosten30.push_back( v310);
        varkosten31.push_back( v311);
        //varkosten40.push_back(v410);
        varkosten41.push_back( v411);
        varkosten50.push_back( v510);
        varkosten51.push_back( v511);
        //varkosten60.push_back(v610);
        varkosten61.push_back( v611);
        varkosten70.push_back( v710);
        varkosten71.push_back( v711);
		varkosten80.push_back( v810);
        varkosten81.push_back( v811);
    }
    for( h = gzniedrigmax + 1; h < gzmittelmax + 1; h++)
    {
        //varkosten10.push_back(v120);
        varkosten11.push_back( v121);
        varkosten20.push_back( v220);
        varkosten21.push_back( v221);
        varkosten30.push_back( v320);
        varkosten31.push_back( v321);
        //varkosten40.push_back(v420);
        varkosten41.push_back( v421);
        varkosten50.push_back( v520);
        varkosten51.push_back( v521);
        //varkosten60.push_back(v620);
        varkosten61.push_back( v621);
        varkosten70.push_back( v720);
        varkosten71.push_back( v721);
		varkosten80.push_back( v820);
        varkosten81.push_back( v821);
    }
    for( h = gzmittelmax + 1; h < gzhochmax + 1; h++)
    {
        //varkosten10.push_back(v130);
        varkosten11.push_back( v131);
        varkosten20.push_back( v230);
        varkosten21.push_back( v231);
        varkosten30.push_back( v330);
        varkosten31.push_back( v331);
        //varkosten40.push_back(v430);
        varkosten41.push_back( v431);
        varkosten50.push_back( v530);
        varkosten51.push_back( v531);
        //varkosten60.push_back(v630);
        varkosten61.push_back( v631);
        varkosten70.push_back( v730);
        varkosten71.push_back( v731);
		varkosten80.push_back( v830);
        varkosten81.push_back( v831);
    }
    for( h = gzhochmax + 1; h < gzsehrhochmax + 1; h++)
    {
        //varkosten10.push_back(v140);
        varkosten11.push_back( v141);
        varkosten20.push_back( v240);
        varkosten21.push_back( v241);
        varkosten30.push_back( v340);
        varkosten31.push_back( v341);
        //varkosten40.push_back(v440);
        varkosten41.push_back( v441);
        varkosten50.push_back( v540);
        varkosten51.push_back( v541);
        //varkosten60.push_back(v640);
        varkosten61.push_back( v641);
        varkosten70.push_back( v740);
        varkosten71.push_back( v741);
		varkosten80.push_back( v840);
        varkosten81.push_back( v841);
    }

    //int  i;

    vector< gruenland*> gliste;

    vector< gruenland*>::iterator j;
    vector< art*>::iterator a;
    int artnr = artlist.size();
    vector< massnahme>::iterator ml;
    int mnr = mliste.size();
    int anzahlgruenland;
    gliste = daten.returngruenland( anzahlgruenland);
    //AfxMessageBox("komme bis hinter die Gruenlandliste",MB_YESNO,0);
    double qualitaet = 0;
    double artqualitaet;
    int n, m; //Zaehler um die nm Matrix zu durchlaufen

    vector< ergebnis::mq>::iterator mqi;
    vector< ergebnis::mq>::reverse_iterator mqlast;
    vector< mgruenland>::iterator mgi;

    pixel*** neue_matrix;
    //die Matrix für das Bundesland erstellt 
    int zeilen, spalten;
    daten.get_matrix_referenz( zeilen, spalten, bundeslandID);
    matrix mat;
    if( egal)
        neue_matrix = mat.create_pixel_matrix( zeilen, spalten, bundeslandID);
    else
        neue_matrix = mat.create_pixel_matrix( zeilen, spalten, bundeslandID,
                hoch);

    ergebnis*** er;
    //die Ergebnismatrix für das Bundesland Sachsen wird erstellt
    er = mat.create_ergebnis_matrix( zeilen, spalten);

    //für ein pixel werden alle massnahmen durchlaufen und sowohl die qualität erzeugt als auch das sich
    // resultierende gruenland -> in die drei ergebnis vecotren werden die Qualität, das Gruenland und 
    // die Massnahme geschoben

//AfxMessageBox("komme bis hinter die Kosten",MB_YESNO,0);

	vector<kosten::verwertbarkeit> verwertung;
	daten.get_verwertbarkeit(verwertung);

    list< int>::iterator git;

    vector< bool**> vorkommen;

    for( int anr = 0; anr < artnr; anr++)
    {

        if( "Schmetterling" == (*(artlist[ anr])).get_gruppe())
        {
            bool** vork = mat.create_vorkommen_matrix( zeilen, spalten,
                    (*(artlist[ anr])).get_artID(),
                    (*(artlist[ anr])).get_ausbreitungsradius(), bundeslandID);
            //AfxMessageBox("Reichweite",MB_YESNO,0);
            vorkommen.push_back( vork);
        }
    }

    //Fuer jede Massnahme wird die Liste der Gruenlandarten erstellt, die sich aus der Massnahme ergeben
    //Diese Listen muessen dann, noch fuer jeden Pixel mit dessen Hoehenlage abgeglichen werden.
    //Fuer jede Massnahme muss noch die Trittmortalitaet mit den Arten aus der Datenbank geholt werden
    //Die Kosten werden berechnet aus den Refkosten + Variablekosten
    //Die Wuchshoehen fuer die drei Wuchsklassen werden fuer die Grossvieheinheit der Massnahme berechnet
    for( ml = mliste.begin(); ml != mliste.end(); ml++)
    {
        list< int> gruenlandID;
        vector< gruenland*> gmliste;
        vector< double> faktorliste;
        bool weide;
        if( (*ml).tierart != 0)
            weide = 1;
        else
            weide = 0;

        gruenlandID = daten.getgruenland_for_massnahme_from_database(
                (*ml).massnahmeID, weide);
        if( weide)
        {
            //AfxMessageBox("weide",MB_YESNO,0);
            for( a = artlist.begin(); a != artlist.end(); a++)
            {
                if( (*a)->get_trittmortalitaettyp() == 0)
                    faktorliste.push_back( 0);
                else
                {
                    double faktor = daten.get_trittmortalitaet( (*ml).tierart,
                            (*a)->get_trittmortalitaettyp());
                    faktorliste.push_back( faktor);
                }
            }
        }

        for( git = gruenlandID.begin(); git != gruenlandID.end(); git++)
        {
            int ID1 = *(git);
            for( j = gliste.begin(); j != gliste.end(); j++)
            {
                if( ID1 == ((*(*j)).gruenlandID))

                    gmliste.push_back( *(j));
            }
        }

        mgruenland mgruen;
        mgruen.gliste = gmliste;
        //mgruen.gliste = gliste;
        mgruen.massnahm = *ml;
        mgruen.faktorliste = faktorliste;

        // die Wuchshoehe berechnen (double besatzdichte_min, double besatzdichte_max, double hoehe_min, double hoehe_max)
        mgruen.hoehe_hoch1 = (*ml).berechne_hanteil( whoehe1.besatzdichte_min,
                whoehe1.besatzdichte_max, whoehe1.hoch_min, whoehe1.hoch_max);
        mgruen.hoehe_hoch2 = (*ml).berechne_hanteil( whoehe2.besatzdichte_min,
                whoehe2.besatzdichte_max, whoehe2.hoch_min, whoehe2.hoch_max);
        mgruen.hoehe_hoch3 = (*ml).berechne_hanteil( whoehe3.besatzdichte_min,
                whoehe3.besatzdichte_max, whoehe3.hoch_min, whoehe3.hoch_max);
        mgruen.hoehe_mittel1 = (*ml).berechne_hanteil( whoehe1.besatzdichte_min,
                whoehe1.besatzdichte_max, whoehe1.mittel_min,
                whoehe1.mittel_max);
        mgruen.hoehe_mittel2 = (*ml).berechne_hanteil( whoehe2.besatzdichte_min,
                whoehe2.besatzdichte_max, whoehe2.mittel_min,
                whoehe2.mittel_max);
        mgruen.hoehe_mittel3 = (*ml).berechne_hanteil( whoehe3.besatzdichte_min,
                whoehe3.besatzdichte_max, whoehe3.mittel_min,
                whoehe3.mittel_max);
        mgruen.hoehe_niedrig1 = (*ml).berechne_hanteil(
                whoehe1.besatzdichte_min, whoehe1.besatzdichte_max,
                whoehe1.niedrig_min, whoehe1.niedrig_max);
        mgruen.hoehe_niedrig2 = (*ml).berechne_hanteil(
                whoehe2.besatzdichte_min, whoehe2.besatzdichte_max,
                whoehe2.niedrig_min, whoehe2.niedrig_max);
        mgruen.hoehe_niedrig3 = (*ml).berechne_hanteil(
                whoehe3.besatzdichte_min, whoehe3.besatzdichte_max,
                whoehe3.niedrig_min, whoehe3.niedrig_max);

        //fuer jede Massnahme die Kosten aus der Datenbank holen und dann die Energiedifferenz berechnen fuer jede Gruenlandzahl
        //Fallunterscheidung anhand der Verfahrennummer um den richtigen Vector mit den Referenzwerten zu holen und auch die Variablenkosten
        vector< double> energiedifferenz( 101);
        vector< double> energiedifferenz_berg( 101);
        kosten kostenm, kostenberg;
        int nummer = (*ml).verfahren_nr;
        int hz;
        //hier die Verschiebung einfügen
        int mv1berg = getenergiehoehe( *ml, false);

        kostenm = kostenm.get_kosten_from_database( nummer, (*ml).mv1massnahme,
                (*ml).abstand2massnahme, (*ml).abstand3massnahme,(*ml).grossvieheinheit, (*ml).tierart,
                (*ml).duengung);
        kostenberg = kostenberg.get_kosten_from_database( nummer, mv1berg,
                (*ml).abstand2massnahme,(*ml).abstand3massnahme, (*ml).grossvieheinheit, (*ml).tierart,
                (*ml).duengung);

        srand (time( NULL) );double
        zufallsadd;
        int addorsub;

        switch( nummer)
        {
            case 2: //Es liegt die Mahd mit 2schnitt vor
                kostenm.berechne_kostendifferenz( ertragv2, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
                kostenberg.berechne_kostendifferenz( ertragv2, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);

                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {
                        /*
                         if(hz == 13)
                         {
                         str.Format(_T("%.2f"),(energiedifferenz[hz]*v2.umrechnungsfaktor));
                         AfxMessageBox(str,MB_YESNO,0);
                         str.Format(_T("%.2f"),varkosten11[hz] - varkosten20[hz]);
                         AfxMessageBox(str,MB_YESNO,0);
                         }
                         if(hz == 40)
                         {
                         str.Format(_T("%.2f"),(energiedifferenz[hz]*v2.umrechnungsfaktor));
                         AfxMessageBox(str,MB_YESNO,0);
                         str.Format(_T("%.2f"),varkosten11[hz] - varkosten20[hz]);
                         AfxMessageBox(str,MB_YESNO,0);
                         }
                         */

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v2.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten20[ hz])
                                + zufallsadd;
                        /*
                         if(hz == 13)
                         {
                         str.Format(_T("%.2f"),energiedifferenz[hz]);
                         AfxMessageBox(str,MB_YESNO,0);
                         }
                         if(hz == 40)
                         {
                         str.Format(_T("%.2f"),energiedifferenz[hz]);
                         AfxMessageBox(str,MB_YESNO,0);
                         }
                         */
                        energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v2.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten20[ hz])
                                + zufallsadd;

                    }

                    else
                    {
                        if( hz == 13)
                        {
                            str.Format( _T( "%.2f"),
                                    (energiedifferenz[ hz]
                                            * v2.umrechnungsfaktor));
                            AfxMessageBox( str, MB_YESNO, 0);
                            str.Format( _T( "%.2f"),
                                    varkosten11[ hz] - varkosten21[ hz]);
                            AfxMessageBox( str, MB_YESNO, 0);
                        }
                        if( hz == 40)
                        {
                            str.Format( _T( "%.2f"),
                                    (energiedifferenz[ hz]
                                            * v2.umrechnungsfaktor));
                            AfxMessageBox( str, MB_YESNO, 0);
                            str.Format( _T( "%.2f"),
                                    varkosten11[ hz] - varkosten21[ hz]);
                            AfxMessageBox( str, MB_YESNO, 0);
                        }

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v2.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten21[ hz])
                                + zufallsadd;

                        energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v2.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten21[ hz])
                                + zufallsadd;
                    }
                }

                break;
            case 3: // Mahd mit 1schnitt
                kostenm.berechne_kostendifferenz( ertragv3, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
                kostenberg.berechne_kostendifferenz( ertragv3, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);
                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {
                        /*if(hz == 33)
                         {
                         str.Format(_T("%.2f"),((energiedifferenz[hz])*0.03));
                         AfxMessageBox(str,MB_YESNO,0);
                         }*/
                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v3.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten30[ hz])
                                + zufallsadd;
                        energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v3.umrechnungsfaktor
                                + (varkosten10[ hz] - varkosten30[ hz])
                                + zufallsadd;
                    } else
                    {
                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v3.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten31[ hz])
                                + zufallsadd;
                        energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v3.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten31[ hz])
                                + zufallsadd;
                    }
                }
                break;
            case 5: //Weide extensiv
                kostenm.berechne_kostendifferenz( ertragv5, refenergie4,
                        refenergie5, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);

                kostenberg.berechne_kostendifferenz( ertragv5, refenergie4,
                        refenergie5, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);
                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {

                        if( energiedifferenz[ hz] != DBL_MAX)
                            energiedifferenz[ hz] = energiedifferenz[ hz]
                                    * v5.umrechnungsfaktor
                                    + (varkosten41[ hz] - varkosten50[ hz])
                                    + zufallsadd;

                        if( energiedifferenz_berg[ hz] != DBL_MAX)
                            energiedifferenz_berg[ hz] =
                                    energiedifferenz_berg[ hz]
                                            * v5.umrechnungsfaktor
                                            + (varkosten41[ hz]
                                                    - varkosten50[ hz])
                                            + zufallsadd;
                    } else
                    {
                        if( energiedifferenz[ hz] != DBL_MAX)
                            energiedifferenz[ hz] = energiedifferenz[ hz]
                                    * v5.umrechnungsfaktor
                                    + (varkosten41[ hz] - varkosten51[ hz])
                                    + zufallsadd;
                        if( energiedifferenz_berg[ hz] != DBL_MAX)
                            energiedifferenz_berg[ hz] =
                                    energiedifferenz_berg[ hz]
                                            * v5.umrechnungsfaktor
                                            + (varkosten41[ hz]
                                                    - varkosten51[ hz])
                                            + zufallsadd;
                    }
                }
                break;
            case 7: //Maehweide extensiv
                kostenm.berechne_kostendifferenz( ertragv7, refenergie6,
                        refenergie7, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
                kostenberg.berechne_kostendifferenz( ertragv7, refenergie6,
                        refenergie7, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);
                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {
                        if( energiedifferenz[ hz] != DBL_MAX)
                            energiedifferenz[ hz] = energiedifferenz[ hz]
                                    * v7.umrechnungsfaktor
                                    + (varkosten61[ hz] - varkosten70[ hz])
                                    + zufallsadd;
                        if( energiedifferenz_berg[ hz] != DBL_MAX)
                            energiedifferenz_berg[ hz] =
                                    energiedifferenz_berg[ hz]
                                            * v7.umrechnungsfaktor
                                            + (varkosten61[ hz]
                                                    - varkosten70[ hz])
                                            + zufallsadd;
                    } else
                    {
                        if( energiedifferenz[ hz] != DBL_MAX)
                            energiedifferenz[ hz] = energiedifferenz[ hz]
                                    * v7.umrechnungsfaktor
                                    + (varkosten61[ hz] - varkosten71[ hz])
                                    + zufallsadd;
                        if( energiedifferenz_berg[ hz] != DBL_MAX)
                            energiedifferenz_berg[ hz] =
                                    energiedifferenz_berg[ hz]
                                            * v7.umrechnungsfaktor
                                            + (varkosten61[ hz]
                                                    - varkosten71[ hz])
                                            + zufallsadd;
                    }
                }
                break;
			case 8: //3Schnitt extensiv
				 kostenm.berechne_kostendifferenz( ertragv8, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
                kostenberg.berechne_kostendifferenz( ertragv8, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);

                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {
                      

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v8.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten80[ hz])
                                + zufallsadd;
                        
                        energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v8.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten80[ hz])
                                + zufallsadd;

                    }

                    else
                    {
                       

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v8.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten81[ hz])
                                + zufallsadd;

                        energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v8.umrechnungsfaktor
                                + (varkosten11[ hz] - varkosten81[ hz])
                                + zufallsadd;
                    }
                }

                break;
            default:
                break;
        }
        vector< double> mgewinn( 101);
        vector< double> mgewinn_berg( 101);

        for( hz = 0; hz < gzsehrhochmax; hz++)
        {

            if( energiedifferenz[ hz] != DBL_MAX)
                mgewinn[ hz] = (*ml).zahlung + energiedifferenz[ hz];
            else
                mgewinn[ hz] = DBL_MAX;

            if( energiedifferenz_berg[ hz] != DBL_MAX)
                mgewinn_berg[ hz] = (*ml).zahlung + energiedifferenz_berg[ hz];
            else
                mgewinn_berg[ hz] = DBL_MAX;

        }

        /*		str.Format(_T("%.2f"),energiedifferenz[13]);
         AfxMessageBox(str,MB_YESNO,0);
         str.Format(_T("%.2f"),energiedifferenz[40]);
         AfxMessageBox(str,MB_YESNO,0);
         str.Format(_T("%.2f"),energiedifferenz[45]);
         AfxMessageBox(str,MB_YESNO,0);*/

        mgruen.kosten = energiedifferenz;
        mgruen.kosten_berg = energiedifferenz_berg;
        mgruen.gewinn = mgewinn;
        mgruen.gewinn_berg = mgewinn_berg;
        massnamegruenlandliste.push_back( mgruen);
    }

    for( n = 0; n < zeilen; n++)
    {
        for( m = 0; m < spalten; m++)
        {
            pixel* pix = neue_matrix[ n][ m];
            //pixel* pix = neue_matrix[2][268];
            ergebnis* ergeb = er[ n][ m];
            ergeb->gesammtqualitaet = 0; // die Gesammtqualitaet ohne Berechnung auf 0 zu setzten und nur wenn erfolgreich modeliert wird auf 1 ändern

            int ref = pix->get_gruenlandzahl();
            ergeb->gruenlandgrundzahl = ref;

            double gqualitaet = 0;
            //int w;
            //die variablen Kosten der Massnahme holen

            if( ref != 0)
            {

                if( (pix->get_feuchte_feucht() != 0)
                        || (pix->get_feuchte_mittel() != 0)
                        || (pix->get_feuchte_trocken() != 0))
                {

                    //für alle Arten und für jede  Maßnahmen

                    bool besatz_ok;
                    for( mgi = massnamegruenlandliste.begin();
                            mgi != massnamegruenlandliste.end(); mgi++)
                    {
                        besatz_ok = false;

                        if( ((*mgi).massnahm.grossvieheinheit == 0)
                                || ((*mgi).massnahm.grossvieheinheit == 99))
                            besatz_ok = true;
                        else
                        {
                            if( (*mgi).gewinn[ ref] == DBL_MAX)
                                besatz_ok = false;
                            else
                            {

                                if( (*mgi).massnahm.mv1massnahme == 1) // bei Ganzjahresstandweide ist der Anteil fest fuer alle Gruenlandzahlen
                                {
                                    besatz_ok = true;
                                    (*mgi).massnahm.hoehenanteil_hoch = 1 / 3.0;
                                    (*mgi).massnahm.hoehenanteil_mittel = 1 / 3.0;
                                    (*mgi).massnahm.hoehenanteil_niedrig = 1 / 3.0;
                                } else
                                {
                                    if( (ref <= gzniedrigmax)
                                            && ((*mgi).massnahm.grossvieheinheit
                                                    <= besatzniedrig))
                                    {
                                        besatz_ok = true;
                                        (*mgi).massnahm.hoehenanteil_hoch =
                                                (*mgi).hoehe_hoch1;
                                        (*mgi).massnahm.hoehenanteil_mittel =
                                                (*mgi).hoehe_mittel1;
                                        (*mgi).massnahm.hoehenanteil_niedrig =
                                                (*mgi).hoehe_niedrig1;

                                    } else
                                    {
                                        if( (ref <= gzmittelmax)
                                                && ((*mgi).massnahm
                                                        .grossvieheinheit
                                                        <= besatzmittel))
                                        {
                                            besatz_ok = true;
                                            (*mgi).massnahm.hoehenanteil_hoch =
                                                    (*mgi).hoehe_hoch2;
                                            (*mgi).massnahm.hoehenanteil_mittel =
                                                    (*mgi).hoehe_mittel2;
                                            (*mgi).massnahm.hoehenanteil_niedrig =
                                                    (*mgi).hoehe_niedrig2;

                                        } else
                                        {
                                            if( (ref <= gzhochmax)
                                                    && ((*mgi).massnahm
                                                            .grossvieheinheit
                                                            <= besatzhoch))
                                            {
                                                besatz_ok = true;
                                                (*mgi).massnahm
                                                        .hoehenanteil_hoch =
                                                        (*mgi).hoehe_hoch2;
                                                (*mgi).massnahm
                                                        .hoehenanteil_mittel =
                                                        (*mgi).hoehe_mittel2;
                                                (*mgi).massnahm
                                                        .hoehenanteil_niedrig =
                                                        (*mgi).hoehe_niedrig2;

                                            } else
                                            {
                                                if( (ref <= gzsehrhochmax)
                                                        && ((*mgi).massnahm
                                                                .grossvieheinheit
                                                                <= besatzsehrhoch))
                                                {
                                                    besatz_ok = true;
                                                    (*mgi).massnahm
                                                            .hoehenanteil_hoch =
                                                            (*mgi).hoehe_hoch3;
                                                    (*mgi).massnahm
                                                            .hoehenanteil_mittel =
                                                            (*mgi).hoehe_mittel3;
                                                    (*mgi).massnahm
                                                            .hoehenanteil_niedrig =
                                                            (*mgi)
                                                                    .hoehe_niedrig3;

                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        //Jeder Pixel hat bereits einen Wert, der besagt ob er Weide/Wiese/Maehweide ist, dementsprechend darf eine Mahd nur auf einem Wiese Pixel vorgenommen werden
                        if( (((pix->get_bearbeitung() == 0)
                                && (((*mgi).massnahm.verfahren_nr == 2)
                                        || ((*mgi).massnahm.verfahren_nr == 3)
                                        || ((*mgi).massnahm.verfahren_nr == 1)
										|| ((*mgi).massnahm.verfahren_nr == 8))))
                                || (((pix->get_bearbeitung() == 1)
                                        && (((*mgi).massnahm.verfahren_nr == 4)
                                                || ((*mgi).massnahm.verfahren_nr
                                                        == 5))))
                                || (((pix->get_bearbeitung() == 2)
                                        && (((*mgi).massnahm.verfahren_nr == 6)
                                                || ((*mgi).massnahm.verfahren_nr
                                                        == 7)))))
                        {
                            if( besatz_ok == true) //falls eine Beweidung vorliegt darf die Anzahl der Tiere nicht die fuer die Gruenlandzahl vorgeschriebene hoechstmenge uebersteigen!
                            {
                                //AfxMessageBox("Vor der Arten schleife",MB_YESNO,0);
                                double artenfaktor = 0;
                                int artenindex = 0;
                                int artenvork = 0;
                                for( a = artlist.begin(); a != artlist.end();
                                        a++)
                                {
                                    if( (*mgi).massnahm.tierart != 0)
                                    {
                                        artenfaktor =
                                                (*mgi).faktorliste[ artenindex];
                                        artenindex++;
                                    }
                                    if( "Schmetterling" == (*a)->get_gruppe())
                                    {
                                        //if( vorkommen[ artenvork][ n][ m]
                                              //  == true)
                                       // {
                                            artqualitaet =
                                                    oeko.habitatqualitaet( *a,
                                                            (*pix),
                                                            (*mgi).massnahm,
                                                            (*mgi).gliste,
                                                            artenfaktor);
                                            //AfxMessageBox("berechne eine Qualitaet",MB_YESNO,0);

                                      //  } else
                                         //   artqualitaet = 0;
                                        artenvork++;
                                    } else
                                        artqualitaet = oeko.habitatqualitaet(
                                                *a, (*pix), (*mgi).massnahm,
                                                (*mgi).gliste, artenfaktor);
                                    //ergeb->artqualitaet[h][w] = artqualitaet;

                                    if( artqualitaet >= minqualitaet)
                                    {
                                        ergebnis::mqart* qartneu;
                                        qartneu = new ergebnis::mqart;
                                        ergebnis::qart* maqneu;
                                        maqneu = new ergebnis::qart;
                                        maqneu->art = *(*a);
                                        maqneu->qualitaet = artqualitaet;
                                        qartneu->massnahm = (*mgi).massnahm;
                                        qartneu->vqart.push_back( *maqneu);
                                        ergeb->artmasqualitaet.push_back(
                                                *qartneu);
                                        qualitaet = qualitaet + artqualitaet;
                                    }

                                    //str.Format(_T("%.5f"),artqualitaet);
                                    //AfxMessageBox(str,MB_YESNO,0);
                                    //w++;

                                }

                                if( qualitaet != 0)
                                {
                                    ergeb->gesammtqualitaet = 1; //Flag um zu erkennen, dass der Pixel erfolgreich modeliert wurde
                                    ergeb->mpixel = *pix;
                                    ergebnis::mq* mqneu;
                                    mqneu = new ergebnis::mq;
                                    mqneu->qualitaet = qualitaet;
                                    mqneu->massnahm = (*mgi).massnahm;
                                    //unterscheiden ob der Pixel hoch liegt, also über 500 m oder unter und entsprechende Kostenladen.

                                    if( (*pix).get_hoehenlage() == 1) //Der Wert für den Berg muss geholt werden
                                    {
                                        //(*mapg).kosten = (*mgi).kosten_berg[ref];
                                        mqneu->gewinn =
                                                (*mgi).gewinn_berg[ ref];
                                    } else // Das Pixel liegt im Tal
                                    {
                                        //(*mapg).kosten = (*mgi).kosten[ref];
                                        mqneu->gewinn = (*mgi).gewinn[ ref];

                                    }

                                    ergeb->massnamehmenqualitaet.push_back(
                                            *mqneu);

                                    //w= 0;
                                    gqualitaet = qualitaet + gqualitaet;
                                    qualitaet = 0;
                                    //h++;

                                }

                            }
                        }
                    }

                    sort( ergeb->massnamehmenqualitaet.begin(),
                            ergeb->massnamehmenqualitaet.end(), myfunction);

                }

                //AfxMessageBox("Komme hinters Pixel",MB_YESNO,0);
            }
        }
    }

    //aufräumen nicht vergessen!
    //AfxMessageBox("Nur noch aufraeumen",MB_YESNO,0);

    for( j = gliste.begin(); j != gliste.end(); j++)
    {
        delete *(j);
    }

    mat.delete_pixel_matrix( neue_matrix, zeilen, spalten);
    return er;

}
int modell::getenergiehoehe( massnahme ma, bool verschiebung1)
{
    int mvneu;
    if( verschiebung1) //die Stauchung in der Hoehe betrifft nur ein Monatsviertel am Anfang und ein MV am Ende
    {
        if( ma.mv1massnahme < 24)
            mvneu = ma.mv1massnahme - 1;
        else
        {
            if( ma.mv1massnahme < 28)
                mvneu = ma.mv1massnahme;
            else
                mvneu = ma.mv1massnahme + 1;
        }

    } else // die Stauchung ist 2 MV am Anfang und Ende
    {
        if( ma.mv1massnahme < 22)
            mvneu = ma.mv1massnahme - 2;
        else
        {
            if( ma.mv1massnahme < 25)
                mvneu = ma.mv1massnahme - 1;
            else
            {
                if( ma.mv1massnahme < 27)
                    mvneu = ma.mv1massnahme;
                else
                {
                    if( ma.mv1massnahme < 30)
                        mvneu = ma.mv1massnahme + 1;
                    else
					{
						if( ma.mv1massnahme < 39)
							mvneu = ma.mv1massnahme + 2;
						else
							 mvneu = 40;
					}
                }
            }
        }
    }

    return mvneu;

}
void modell::calculate_oekologiemodell(
        vector< art*> artlist,
        vector< massnahme> mliste,
        vector< double> minqualitaet,
        vector< vector< modell::masspixelergeb>>& massnahmenergebvector,
        int bundeslandID,
        bool hoch,
        bool egal)
{

    datenbank daten;
    oekologie oeko;
    //die Massnahmen sind vorgegeben
    //Als erstes die Gruenlandzahlen Grenzen fuer die 4 Ertragsklassen holen!!!
    int gzniedrigmax, gzmittelmax, gzhochmax, gzsehrhochmax;
    double besatzniedrig, besatzmittel, besatzhoch, besatzsehrhoch;
    daten.get_ertrags_besatz_grenzen( gzniedrigmax, gzmittelmax, gzhochmax,
            gzsehrhochmax, besatzniedrig, besatzmittel, besatzhoch,
            besatzsehrhoch);
	daten.get_bundesland(bundeslandID, oeko.start, oeko.niedrig, oeko.mittel);
    wuchshoehe whoehe1, whoehe2, whoehe3; //Die Wuchshoehen die sich bei Beweidung einstellen fuer die drei Wuchsklassen
    whoehe1 = whoehe1.get_wuchshoehe_from_database( 1);
    whoehe2 = whoehe2.get_wuchshoehe_from_database( 2);
    whoehe3 = whoehe3.get_wuchshoehe_from_database( 3);
    //AfxMessageBox("komme bis hier",MB_YESNO,0);

    verfahren_ertrag v1, v2, v3, v4, v5, v6, v7, v8, v9, v10; //Es werden genau 7 Verfahren betrachtet
    v1 = v1.get_verfahren_kosten_from_database( 1);
    v2 = v2.get_verfahren_kosten_from_database( 2);
    v3 = v3.get_verfahren_kosten_from_database( 3);
    v4 = v4.get_verfahren_kosten_from_database( 4);
    v5 = v5.get_verfahren_kosten_from_database( 5);
    v6 = v6.get_verfahren_kosten_from_database( 6);
    v7 = v7.get_verfahren_kosten_from_database( 7);
	v8 = v8.get_verfahren_kosten_from_database( 8);
	v9 = v9.get_verfahren_kosten_from_database( 9);
	v10 = v10.get_verfahren_kosten_from_database( 10);
    //Fuer jedes Verfahren werden anhand der geladenen Daten die Ertragswerte fuer die einzelnen 
    //Gruenlandzahlen berechnet und in einen Vector gespeichert-> genau 100 Werte, der Vector hat groesse 101
    vector< double> ertragv1( 101);
    vector< double> ertragv2( 101);
    vector< double> ertragv3( 101);
    vector< double> ertragv4( 101);
    vector< double> ertragv5( 101);
    vector< double> ertragv6( 101);
    vector< double> ertragv7( 101);
	vector< double> ertragv8( 101);
	vector< double> ertragv9( 101);
	vector< double> ertragv10( 101);


    for( int i = 0; i < 101; i++)
    {
        ertragv1[ i] = 0;
        ertragv2[ i] = 0;
        ertragv3[ i] = 0;
        ertragv4[ i] = 0;
        ertragv5[ i] = 0;
        ertragv6[ i] = 0;
        ertragv7[ i] = 0;
		ertragv8[ i] = 0;
		ertragv9[ i] = 0;
		ertragv10[ i] = 0;
    }

    v1.berechne_gzertrag( v1.gruenlandzahl1, v1.gruenlandzahl2,
            v1.gruenlandzahl3, v1.gruenlandzahl4, v1.ertrag1, v1.ertrag2,
            v1.ertrag3, v1.ertrag4, ertragv1);
    v2.berechne_gzertrag( v2.gruenlandzahl1, v2.gruenlandzahl2,
            v2.gruenlandzahl3, v2.gruenlandzahl4, v2.ertrag1, v2.ertrag2,
            v2.ertrag3, v2.ertrag4, ertragv2);
    v3.berechne_gzertrag( v3.gruenlandzahl1, v3.gruenlandzahl2,
            v3.gruenlandzahl3, v3.gruenlandzahl4, v3.ertrag1, v3.ertrag2,
            v3.ertrag3, v3.ertrag4, ertragv3);
    v4.berechne_gzertrag( v4.gruenlandzahl1, v4.gruenlandzahl2,
            v4.gruenlandzahl3, v4.gruenlandzahl4, v4.ertrag1, v4.ertrag2,
            v4.ertrag3, v4.ertrag4, ertragv4);
    v5.berechne_gzertrag( v5.gruenlandzahl1, v5.gruenlandzahl2,
            v5.gruenlandzahl3, v5.gruenlandzahl4, v5.ertrag1, v5.ertrag2,
            v5.ertrag3, v5.ertrag4, ertragv5);
    v6.berechne_gzertrag( v6.gruenlandzahl1, v6.gruenlandzahl2,
            v6.gruenlandzahl3, v6.gruenlandzahl4, v6.ertrag1, v6.ertrag2,
            v6.ertrag3, v6.ertrag4, ertragv6);
    v7.berechne_gzertrag( v7.gruenlandzahl1, v7.gruenlandzahl2,
            v7.gruenlandzahl3, v7.gruenlandzahl4, v7.ertrag1, v7.ertrag2,
            v7.ertrag3, v7.ertrag4, ertragv7);
	v8.berechne_gzertrag( v8.gruenlandzahl1, v8.gruenlandzahl2,
            v8.gruenlandzahl3, v8.gruenlandzahl4, v8.ertrag1, v8.ertrag2,
            v8.ertrag3, v8.ertrag4, ertragv8);
	v9.berechne_gzertrag( v9.gruenlandzahl1, v9.gruenlandzahl2,
            v9.gruenlandzahl3, v9.gruenlandzahl4, v9.ertrag1, v9.ertrag2,
            v9.ertrag3, v9.ertrag4, ertragv9);
	v10.berechne_gzertrag( v10.gruenlandzahl1, v10.gruenlandzahl2,
            v10.gruenlandzahl3, v10.gruenlandzahl4, v10.ertrag1, v10.ertrag2,
            v10.ertrag3, v10.ertrag4, ertragv10);

    vector< double>::iterator vi;
   

    // Fuer die Referenzverfahren koennen nun schon anhand der Ertraege die Energiewerte fuer jede Gruenlandzahl berechnet werden
    vector< double> refenergie1( 101);
    vector< double> refenergie4( 101);
    vector< double> refenergie6( 101);
    vector< double> refenergie5( 101); //extensive Referenz um sicherzustellen, daß nicht zu viele Tiere auf der Weide sind
    vector< double> refenergie7( 101); //extensive Referenz um sicherzustellen, daß nicht zu viele Tiere auf der Weide sind

    for( int i = 0; i < 101; i++)
    {
        refenergie1[ i] = 0;
        refenergie4[ i] = 0;
        refenergie6[ i] = 0;
        refenergie5[ i] = 0;
        refenergie7[ i] = 0;
    }

    v1.berechne_referenz( ertragv1, 1, refenergie1); //der 3Schnitt
    v4.berechne_referenz( ertragv4, 4, refenergie4); //die intensive Weide
    v5.berechne_referenz( ertragv5, 4, refenergie5); //die extensive Weide
    v6.berechne_referenz( ertragv6, 6, refenergie6); //die intensive Maehweide
    v7.berechne_referenz( ertragv7, 6, refenergie7); //die extensive Maehweide

    //AfxMessageBox("ertrag",MB_YESNO,0);
    int hel = 0;
    

    //Fuer jedes Verfahren die variablen Kosten aus der Datenbank geholt und jeweils in einem Vector fuer alle Gruenlandzahlen
    //gespeichert auch wenn fuer die 4 Leistungsklassen der Wert gleich ist : solange maehweide noch nicht drinn ist nur 5 Verfahren!!!
    //variablekosten vark1,vark2, vark3,vark4,vark5,vark6,vark7;
    variablekosten vark;
    vector< variablekosten> vk1, vk2, vk3, vk4, vk5, vk6, vk7, vk8, vk9, vk10;
    vark.get_kosten_from_database( 1, vk1);
    vark.get_kosten_from_database( 2, vk2);
    vark.get_kosten_from_database( 3, vk3);
    vark.get_kosten_from_database( 4, vk4);
    vark.get_kosten_from_database( 5, vk5);
    vark.get_kosten_from_database( 6, vk6);
    vark.get_kosten_from_database( 7, vk7);
	vark.get_kosten_from_database( 8, vk8);
	vark.get_kosten_from_database( 9, vk9);
	vark.get_kosten_from_database( 10, vk10);

    vector< double> varkosten10, varkosten11; //wird fuer jede Gruenlandzahl die variablen Kosten des ersten Verfahrens  beinhalten
    double v111, v121, v131, v141;
    CString str;
    //Die Referenzkosten sind immer nur mit Düngung!
    v111 = vk1[ 0].berechne_variablekosten( 1);
    v121 = vk1[ 1].berechne_variablekosten( 1);
    v131 = vk1[ 2].berechne_variablekosten( 1);
    v141 = vk1[ 3].berechne_variablekosten( 1);
    vector< double> varkosten20, varkosten21;
    double v210, v211, v220, v221, v230, v231, v240, v241;
    v210 = vk2[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v211 = vk2[ 0].berechne_variablekosten( 1);
    /*	str.Format(_T("%.2f"),v210);
     AfxMessageBox(str,MB_YESNO,0);
     str.Format(_T("%.2f"),v211);
     AfxMessageBox(str,MB_YESNO,0);*/
    v220 = vk2[ 1].berechne_variablekosten( 0);
    v221 = vk2[ 1].berechne_variablekosten( 1);
    v230 = vk2[ 2].berechne_variablekosten( 0);
    v231 = vk2[ 2].berechne_variablekosten( 1);
    v240 = vk2[ 3].berechne_variablekosten( 0);
    v241 = vk2[ 3].berechne_variablekosten( 1);
    vector< double> varkosten30, varkosten31;
    double v310, v311, v320, v321, v330, v331, v340, v341;
    v310 = vk3[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v311 = vk3[ 0].berechne_variablekosten( 1);
    v320 = vk3[ 1].berechne_variablekosten( 0);
    v321 = vk3[ 1].berechne_variablekosten( 1);
    v330 = vk3[ 2].berechne_variablekosten( 0);
    v331 = vk3[ 2].berechne_variablekosten( 1);
    v340 = vk3[ 3].berechne_variablekosten( 0);
    v341 = vk3[ 3].berechne_variablekosten( 1);
    vector< double> varkosten40, varkosten41;
    //Die Referenzkosten sind immer nur mit Düngung!
    double v411, v421, v431, v441;
    v411 = vk4[ 0].berechne_variablekosten( 1);
    v421 = vk4[ 1].berechne_variablekosten( 1);
    v431 = vk4[ 2].berechne_variablekosten( 1);
    v441 = vk4[ 3].berechne_variablekosten( 1);
    vector< double> varkosten50, varkosten51;
    double v510, v511, v520, v521, v530, v531, v540, v541;
    v510 = vk5[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v511 = vk5[ 0].berechne_variablekosten( 1);
    v520 = vk5[ 1].berechne_variablekosten( 0);
    v521 = vk5[ 1].berechne_variablekosten( 1);
    v530 = vk5[ 2].berechne_variablekosten( 0);
    v531 = vk5[ 2].berechne_variablekosten( 1);
    v540 = vk5[ 3].berechne_variablekosten( 0);
    v541 = vk5[ 3].berechne_variablekosten( 1);
    vector< double> varkosten60, varkosten61;
    double v611, v621, v631, v641;
    //Die Referenzkosten sind immer nur mit Düngung!	
    v611 = vk6[ 0].berechne_variablekosten( 1);
    v621 = vk6[ 1].berechne_variablekosten( 1);
    v631 = vk6[ 2].berechne_variablekosten( 1);
    v641 = vk6[ 3].berechne_variablekosten( 1);
    vector< double> varkosten70, varkosten71;
    double v710, v711, v720, v721, v730, v731, v740, v741;
    v710 = vk7[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v711 = vk7[ 0].berechne_variablekosten( 1);
    v720 = vk7[ 1].berechne_variablekosten( 0);
    v721 = vk7[ 1].berechne_variablekosten( 1);
    v730 = vk7[ 2].berechne_variablekosten( 0);
    v731 = vk7[ 2].berechne_variablekosten( 1);
    v740 = vk7[ 3].berechne_variablekosten( 0);
    v741 = vk7[ 3].berechne_variablekosten( 1);
	vector< double> varkosten80, varkosten81;
    double v810, v811, v820, v821, v830, v831, v840, v841;
    v810 = vk8[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v811 = vk8[ 0].berechne_variablekosten( 1);
    v820 = vk8[ 1].berechne_variablekosten( 0);
    v821 = vk8[ 1].berechne_variablekosten( 1);
    v830 = vk8[ 2].berechne_variablekosten( 0);
    v831 = vk8[ 2].berechne_variablekosten( 1);
    v840 = vk8[ 3].berechne_variablekosten( 0);
    v841 = vk8[ 3].berechne_variablekosten( 1);
	vector< double> varkosten90, varkosten91;
	double v910, v911, v920, v921, v930, v931, v940, v941;
    v910 = vk9[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v911 = vk9[ 0].berechne_variablekosten( 1);
    v920 = vk9[ 1].berechne_variablekosten( 0);
    v921 = vk9[ 1].berechne_variablekosten( 1);
    v930 = vk9[ 2].berechne_variablekosten( 0);
    v931 = vk9[ 2].berechne_variablekosten( 1);
    v940 = vk9[ 3].berechne_variablekosten( 0);
    v941 = vk9[ 3].berechne_variablekosten( 1);
	vector< double> varkosten100, varkosten101;
	double v1010, v1011, v1020, v1021, v1030, v1031, v1040, v1041;
    v1010 = vk10[ 0].berechne_variablekosten( 0); //jeweils mit Duengung->1 und ohne Duengung ->0
    v1011 = vk10[ 0].berechne_variablekosten( 1);
    v1020 = vk10[ 1].berechne_variablekosten( 0);
    v1021 = vk10[ 1].berechne_variablekosten( 1);
    v1030 = vk10[ 2].berechne_variablekosten( 0);
    v1031 = vk10[ 2].berechne_variablekosten( 1);
    v1040 = vk10[ 3].berechne_variablekosten( 0);
    v1041 = vk10[ 3].berechne_variablekosten( 1);
	//Die Varkosten löschen, da sie nicht mehr gebraucht werden
    int h;
    for( h = 0; h < gzniedrigmax + 1; h++)
    {
        varkosten11.push_back( v111);
        varkosten20.push_back( v210);
        varkosten21.push_back( v211);
        varkosten30.push_back( v310);
        varkosten31.push_back( v311);
        varkosten41.push_back( v411);
        varkosten50.push_back( v510);
        varkosten51.push_back( v511);
        varkosten61.push_back( v611);
        varkosten70.push_back( v710);
        varkosten71.push_back( v711);
		varkosten80.push_back( v810);
        varkosten81.push_back( v811);
		varkosten90.push_back( v910);
        varkosten91.push_back( v911);
		varkosten100.push_back( v1010);
        varkosten101.push_back( v1011);
    }
    for( h = gzniedrigmax + 1; h < gzmittelmax + 1; h++)
    {
        varkosten11.push_back( v121);
        varkosten20.push_back( v220);
        varkosten21.push_back( v221);
        varkosten30.push_back( v320);
        varkosten31.push_back( v321);
        varkosten41.push_back( v421);
        varkosten50.push_back( v520);
        varkosten51.push_back( v521);
        varkosten61.push_back( v621);
        varkosten70.push_back( v720);
        varkosten71.push_back( v721);
		varkosten80.push_back( v820);
        varkosten81.push_back( v821);
		varkosten90.push_back( v920);
        varkosten91.push_back( v921);
		varkosten100.push_back( v1020);
        varkosten101.push_back( v1021);
    }
    for( h = gzmittelmax + 1; h < gzhochmax + 1; h++)
    {
        varkosten11.push_back( v131);
        varkosten20.push_back( v230);
        varkosten21.push_back( v231);
        varkosten30.push_back( v330);
        varkosten31.push_back( v331);
        varkosten41.push_back( v431);
        varkosten50.push_back( v530);
        varkosten51.push_back( v531);
        varkosten61.push_back( v631);
        varkosten70.push_back( v730);
        varkosten71.push_back( v731);
		varkosten80.push_back( v830);
        varkosten81.push_back( v831);
		varkosten90.push_back( v930);
        varkosten91.push_back( v931);
		varkosten100.push_back( v1030);
        varkosten101.push_back( v1031);
    }
    for( h = gzhochmax + 1; h < gzsehrhochmax + 1; h++)
    {
        varkosten11.push_back( v141);
        varkosten20.push_back( v240);
        varkosten21.push_back( v241);
        varkosten30.push_back( v340);
        varkosten31.push_back( v341);
        varkosten41.push_back( v441);
        varkosten50.push_back( v540);
        varkosten51.push_back( v541);
        varkosten61.push_back( v641);
        varkosten70.push_back( v740);
        varkosten71.push_back( v741);
		varkosten80.push_back( v840);
        varkosten81.push_back( v841);
		varkosten90.push_back( v940);
        varkosten91.push_back( v941);
		varkosten100.push_back( v1040);
        varkosten101.push_back( v1041);
    }

    vector< gruenland*> gliste;

    vector< gruenland*>::iterator j;
    vector< art*>::iterator a;
    int artnr = artlist.size();
    vector< massnahme>::iterator ml;
    int mnr = mliste.size();
    int anzahlgruenland;
    gliste = daten.returngruenland( anzahlgruenland);
    //AfxMessageBox("komme bis hinter die Gruenlandliste",MB_YESNO,0);
    double qualitaet = 0;
    double artqualitaet;
    int n, m; //Zaehler um die nm Matrix zu durchlaufen

    vector< mgruenland>::iterator mgi;

    pixel*** neue_matrix;
    //die Matrix für das Bundesland Sachsen wird erstellt mit 677 zeilen und 888 Spalten
    int zeilen, spalten;
    daten.get_matrix_referenz( zeilen, spalten, bundeslandID);
    //AfxMessageBox("1",MB_YESNO,0);
    matrix mat;
    if( egal)
        neue_matrix = mat.create_pixel_matrix( zeilen, spalten, bundeslandID);
    else
        neue_matrix = mat.create_pixel_matrix( zeilen, spalten, bundeslandID,
                hoch);
   // AfxMessageBox("2",MB_YESNO,0);

	vector<kosten::verwertbarkeit> verwertung;
	daten.get_verwertbarkeit(verwertung);


    //für ein pixel werden alle massnahmen durchlaufen und sowohl die qualität erzeugt als auch das sich
    // resultierende gruenland -> in die drei ergebnis vecotren werden die Qualität, das Gruenland und 
    // die Massnahme geschoben

//AfxMessageBox("komme bis hinter die Kosten",MB_YESNO,0);

    list< int>::iterator git;
    const int artnumber = artlist.size()+5;
	 int v = 0;
   vector< bool**> vorkommen(artnumber);
	//bool** vork;
	

    for( int anr = 0; anr < artnr; anr++)
    {

        if( "Schmetterling" == (*(artlist[ anr])).get_gruppe())
        {
			
            bool** vork = mat.create_vorkommen_matrix( zeilen, spalten,
                    (*(artlist[ anr])).get_artID(),
                    (*(artlist[ anr])).get_ausbreitungsradius(), bundeslandID);
            //AfxMessageBox("Reichweite",MB_YESNO,0);
			
            vorkommen[v]= vork;
			v++;
/*
			int i, j;
			for(  i = 0; i < zeilen; i++)
			{
				for(j = 0; j< spalten; j++)
				{
					vork[ i][j] = false ;
				}
			}
			
			
			 int i, j;
			 for( i = 0; i < zeilen; i++)
			{

				delete[] vork[ i];
			}
			delete[] vork;*/
		}
    }

    //Fuer jede Massnahme wird die Liste der Gruenlandarten erstellt, die sich aus der Massnahme ergeben
    //Diese Listen muessen dann, noch fuer jeden Pixel mit dessen Hoehenlage abgeglichen werden.
    //Fuer jede Massnahme muss noch die Trittmortalitaet mit den Arten aus der Datenbank geholt werden
    //Die Kosten werden berechnet aus den Refkosten + Variablekosten
    //Die Wuchshoehen fuer die drei Wuchsklassen werden fuer die Grossvieheinheit der Massnahme berechnet

    //AfxMessageBox("Energiedifferenz",MB_YESNO,0);
	
    for( ml = mliste.begin(); ml != mliste.end(); ml++)
    {
        //vector<modell::masspixelergeb> masspixelergebliste(0);
        //massnahmenergebvector.push_back(masspixelergebliste);
        list< int> gruenlandID;
        vector< gruenland*> gmliste;
        vector< double> faktorliste(artnumber);
		mgruenland mgruen;
        bool weide;
        if( (*ml).tierart != 0 && (*ml).grossvieheinheit < 60) //Umtriebsweide wird nicht wie Weide bzgl der Trittmortalität behandelt,deshalb <60
            weide = 1;
        else
            weide = 0;

        gruenlandID = daten.getgruenland_for_massnahme_from_database(
                (*ml).massnahmeID, weide);
		
        if( weide)
        {
            //AfxMessageBox("weide",MB_YESNO,0);
			v = 0;
            for( a = artlist.begin(); a != artlist.end(); a++)
            {
                if( (*a)->get_trittmortalitaettyp() == 0)
                    faktorliste[v] = 0;
                else
                {
                    double faktor = daten.get_trittmortalitaet( (*ml).tierart,
                            (*a)->get_trittmortalitaettyp());
                    faktorliste[v]= faktor;
                }
				v++;
            }
        }

        for( git = gruenlandID.begin(); git != gruenlandID.end(); git++)
        {
            int ID1 = *(git);
            for( j = gliste.begin(); j != gliste.end(); j++)
            {
                if( ID1 == ((*(*j)).gruenlandID))

                    gmliste.push_back( *(j));
            }
        }

       // mgruenland mgruen;
        mgruen.gliste = gmliste;
        //mgruen.gliste = gliste;
        mgruen.massnahm = *ml;
        mgruen.faktorliste = faktorliste;
		
		if(weide)
		{

        // die Wuchshoehe berechnen (double besatzdichte_min, double besatzdichte_max, double hoehe_min, double hoehe_max)
			mgruen.hoehe_hoch1 = (*ml).berechne_hanteil( whoehe1.besatzdichte_min,
					whoehe1.besatzdichte_max, whoehe1.hoch_min, whoehe1.hoch_max);
			mgruen.hoehe_hoch2 = (*ml).berechne_hanteil( whoehe2.besatzdichte_min,
					whoehe2.besatzdichte_max, whoehe2.hoch_min, whoehe2.hoch_max);
			mgruen.hoehe_hoch3 = (*ml).berechne_hanteil( whoehe3.besatzdichte_min,
					whoehe3.besatzdichte_max, whoehe3.hoch_min, whoehe3.hoch_max);
			mgruen.hoehe_mittel1 = (*ml).berechne_hanteil( whoehe1.besatzdichte_min,
					whoehe1.besatzdichte_max, whoehe1.mittel_min,
					whoehe1.mittel_max);
			mgruen.hoehe_mittel2 = (*ml).berechne_hanteil( whoehe2.besatzdichte_min,
					whoehe2.besatzdichte_max, whoehe2.mittel_min,
					whoehe2.mittel_max);
			mgruen.hoehe_mittel3 = (*ml).berechne_hanteil( whoehe3.besatzdichte_min,
					whoehe3.besatzdichte_max, whoehe3.mittel_min,
					whoehe3.mittel_max);
			mgruen.hoehe_niedrig1 = (*ml).berechne_hanteil(
					whoehe1.besatzdichte_min, whoehe1.besatzdichte_max,
					whoehe1.niedrig_min, whoehe1.niedrig_max);
			mgruen.hoehe_niedrig2 = (*ml).berechne_hanteil(
					whoehe2.besatzdichte_min, whoehe2.besatzdichte_max,
					whoehe2.niedrig_min, whoehe2.niedrig_max);
			mgruen.hoehe_niedrig3 = (*ml).berechne_hanteil(
					whoehe3.besatzdichte_min, whoehe3.besatzdichte_max,
					whoehe3.niedrig_min, whoehe3.niedrig_max);
		}
		else
		{
			mgruen.hoehe_hoch1 = 0;
			mgruen.hoehe_hoch2 = 0;
			mgruen.hoehe_hoch3 = 0;
			mgruen.hoehe_mittel1 = 0;
			mgruen.hoehe_mittel2 = 0;
			mgruen.hoehe_mittel3 = 0;
			mgruen.hoehe_niedrig1 = 0;
			mgruen.hoehe_niedrig2 = 0;
			mgruen.hoehe_niedrig3 = 0;
		}

        //fuer jede Massnahme die Kosten aus der Datenbank holen und dann die Energiedifferenz berechnen fuer jede Gruenlandzahl
        //Fallunterscheidung anhand der Verfahrennummer um den richtigen Vector mit den Referenzwerten zu holen und auch die Variablenkosten
        vector< double> energiedifferenz( 101);
        vector< double> energiedifferenz_berg( 101);
        for( int i = 0; i < 101; i++)
        {
            energiedifferenz[ i] = 0;
            energiedifferenz_berg[ i] = 0;
        }

        kosten kostenm, kostenberg;
        int nummer = (*ml).verfahren_nr;
        int hz;
        //hier die Verschiebung einfügen
        int mv1berg = getenergiehoehe( *ml, false);

        if( nummer != 1)
        {
            kostenm = kostenm.get_kosten_from_database( nummer,
                    (*ml).mv1massnahme, (*ml).abstand2massnahme,(*ml).abstand3massnahme,
                    (*ml).grossvieheinheit, (*ml).tierart, (*ml).duengung);
			if(mv1berg > 18)
				kostenberg = kostenberg.get_kosten_from_database( nummer, mv1berg,
                    (*ml).abstand2massnahme, (*ml).abstand3massnahme, (*ml).grossvieheinheit,
                    (*ml).tierart, (*ml).duengung);
        }

        srand (time( NULL) );double
        zufallsadd;
        int addorsub;
		double vardiff;
        switch( nummer)
        {
            case 1: //der Referenzzustand: keine Kosten entstehen
                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    energiedifferenz[ hz] = 0;
                    energiedifferenz_berg[ hz] = 0;
                }
                break;
            case 2: //Es liegt die Mahd mit 2schnitt vor
                kostenm.berechne_kostendifferenz( ertragv2, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
				if(mv1berg > 18)
					kostenberg.berechne_kostendifferenz( ertragv2, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);
				

                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);
					

                    if( (*ml).duengung == 0)
                    {
						if((*ml).streifenmahd)
							vardiff = varkosten11[ hz] - (varkosten20[ hz] * 0.96) - (varkosten11[ hz]* 0.04);
						else
							vardiff = varkosten11[ hz] - varkosten20[ hz];

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v2.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;
						if(mv1berg > 18)
							energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v2.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;
						//str.Format(_T("%.2f"),(varkosten11[hz] - varkosten20[hz]));
                        //AfxMessageBox(str,MB_YESNO,0);

                    }

                    else
                    {

                        //str.Format(_T("%.2f"),(varkosten11[hz] - varkosten21[hz]));
                        //AfxMessageBox(str,MB_YESNO,0);
						if((*ml).streifenmahd)
							vardiff = varkosten11[ hz] - (varkosten21[ hz] * 0.96) - (varkosten11[ hz]* 0.04);
						else
							vardiff = varkosten11[ hz] - varkosten21[ hz];

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v2.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;
                        if(mv1berg > 18)
							energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v2.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;

                    }
                }

                break;
            case 3: // Mahd mit 1schnitt
                kostenm.berechne_kostendifferenz( ertragv3, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
				if(mv1berg > 18)
					kostenberg.berechne_kostendifferenz( ertragv3, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);
                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);
					

                    if( (*ml).duengung == 0)
                    {
						if((*ml).streifenmahd)
							vardiff = varkosten11[ hz] - (varkosten30[ hz] * 0.96) - (varkosten11[ hz]* 0.04);
						else
							vardiff = varkosten11[ hz] - varkosten30[ hz];

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v3.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;
						if(mv1berg > 18)
							energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v3.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;
                        /*
                         if(hz == 13)
                         {
                         
                         str.Format(_T("%.2f"),(energiedifferenz[hz]));
                         AfxMessageBox(str,MB_YESNO,0);
                         str.Format(_T("%.2f"),varkosten30[hz]);
                         AfxMessageBox(str,MB_YESNO,0);
                         
                         }
                         if(hz == 40)
                         {
                         str.Format(_T("%.2f"),(energiedifferenz[hz]));
                         AfxMessageBox(str,MB_YESNO,0);
                         str.Format(_T("%.2f"),varkosten30[hz]);
                         AfxMessageBox(str,MB_YESNO,0);
                         }
                         
                         
                         if(hz == 45)
                         {
                         str.Format(_T("%.2f"),(energiedifferenz[hz]));
                         AfxMessageBox(str,MB_YESNO,0);
                         str.Format(_T("%.2f"),varkosten30[hz]);
                         AfxMessageBox(str,MB_YESNO,0);
                         }
                         */
                    } else
                    {
						if((*ml).streifenmahd)
							vardiff = varkosten11[ hz] - (varkosten31[ hz] * 0.96) - (varkosten11[ hz]* 0.04);
						else
							vardiff = varkosten11[ hz] - varkosten31[ hz];

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v3.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;
						if(mv1berg > 18)
							energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v3.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;
                    }
                }
                break;
            case 5: //Weide extensiv
                kostenm.berechne_kostendifferenz( ertragv5, refenergie4,
                        refenergie5, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
				if(mv1berg > 18)
					kostenberg.berechne_kostendifferenz( ertragv5, refenergie4,
                        refenergie5, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);
                for( hz = 0; hz < gzsehrhochmax; hz++)
                {

                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {
                        if( energiedifferenz[ hz] < (DBL_MAX - 1))
                            energiedifferenz[ hz] = energiedifferenz[ hz]
                                    * v5.umrechnungsfaktor
                                    + (varkosten41[ hz] - varkosten50[ hz])
                                    + zufallsadd;
			
						if(mv1berg > 18)
						{
						 if( energiedifferenz_berg[ hz] < (DBL_MAX - 1))
                            energiedifferenz_berg[ hz] =
                                    energiedifferenz_berg[ hz]
                                            * v5.umrechnungsfaktor
                                            + (varkosten41[ hz]
                                                    - varkosten50[ hz])
                                            + zufallsadd;
						}
                    } else
                    {
                        if( energiedifferenz[ hz] < (DBL_MAX - 1))
                            energiedifferenz[ hz] = energiedifferenz[ hz]
                                    * v5.umrechnungsfaktor
                                    + (varkosten41[ hz] - varkosten51[ hz])
                                    + zufallsadd;
						if(mv1berg > 18)
						{
							if( energiedifferenz_berg[ hz] < (DBL_MAX - 1))
								energiedifferenz_berg[ hz] =
										energiedifferenz_berg[ hz]
												* v5.umrechnungsfaktor
												+ (varkosten41[ hz]
														- varkosten51[ hz])
												+ zufallsadd;
						}
                    }
                }
                break;
            case 7: //Maehweide extensiv
                kostenm.berechne_kostendifferenz( ertragv7, refenergie6,
                        refenergie7, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
				if(mv1berg > 18)
					kostenberg.berechne_kostendifferenz( ertragv7, refenergie6,
                        refenergie7, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);
                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {
                        if( energiedifferenz[ hz] < (DBL_MAX - 1))
                            energiedifferenz[ hz] = energiedifferenz[ hz]
                                    * v7.umrechnungsfaktor
                                    + (varkosten61[ hz] - varkosten70[ hz])
                                    + zufallsadd;
						if(mv1berg > 18)
						{
							if( energiedifferenz_berg[ hz] < (DBL_MAX - 1))
								energiedifferenz_berg[ hz] =
										energiedifferenz_berg[ hz]
												* v7.umrechnungsfaktor
												+ (varkosten61[ hz] - varkosten70[ hz])
												+ zufallsadd;
						}

                    } else
                    {
                        if( energiedifferenz[ hz] < (DBL_MAX - 1))
                            energiedifferenz[ hz] = energiedifferenz[ hz]
                                    * v7.umrechnungsfaktor
                                    + (varkosten61[ hz] - varkosten71[ hz])
                                    + zufallsadd;
						if(mv1berg > 18)
						{
							if( energiedifferenz_berg[ hz] < (DBL_MAX - 1))
								energiedifferenz_berg[ hz] =
										energiedifferenz_berg[ hz]
												* v7.umrechnungsfaktor
												+ (varkosten61[ hz] - varkosten71[ hz])
												+ zufallsadd;
						}

                    }
                }
                break;
			case 8: //Es liegt die Mahd mit 3schnitt vor
                kostenm.berechne_kostendifferenz( ertragv8, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
				if(mv1berg > 18)
					kostenberg.berechne_kostendifferenz( ertragv8, refenergie1,
                        refenergie1, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);

				

                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {
						if((*ml).streifenmahd)
							vardiff = varkosten11[ hz] - (varkosten80[ hz] * 0.96) - (varkosten11[ hz]* 0.004);
						else
							vardiff = varkosten11[ hz] - varkosten80[ hz];


                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v8.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;

						if(mv1berg > 18)
                         energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v8.umrechnungsfaktor
                                + vardiff
                                + zufallsadd;
						//str.Format(_T("%.2f"),(varkosten11[hz] - varkosten80[hz]));
                       // AfxMessageBox(str,MB_YESNO,0);

                    }

                    else
                    {

                      

						if((*ml).streifenmahd)
						{
							energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v8.umrechnungsfaktor  +(varkosten11[ hz] * 0.04) + zufallsadd;
						}
						else
						{

							energiedifferenz[ hz] = energiedifferenz[ hz]
									* v8.umrechnungsfaktor
									+ (varkosten11[ hz] - varkosten81[ hz])
									+ zufallsadd;
							if(mv1berg > 18)
							 energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
									* v8.umrechnungsfaktor
									+ (varkosten11[ hz] - varkosten81[ hz])
									+ zufallsadd;
						}

                    }
                }

                break;
			case 9: //Es liegt die Maehweide mit 3 Arbeitsgaengen vor
                kostenm.berechne_kostendifferenz( ertragv9, refenergie6,
                        refenergie6, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
				if(mv1berg > 18)
					kostenberg.berechne_kostendifferenz( ertragv9, refenergie6,
                        refenergie6, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);

                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v9.umrechnungsfaktor
                                + (varkosten61[ hz] - varkosten90[ hz])
                                + zufallsadd;

						if(mv1berg > 18)
						 energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v9.umrechnungsfaktor
                                + (varkosten61[ hz] - varkosten90[ hz])
                                + zufallsadd;
						//str.Format(_T("%.2f"),(varkosten11[hz] - varkosten80[hz]));
                       // AfxMessageBox(str,MB_YESNO,0);

                    }

                    else
                    {

                        //str.Format(_T("%.2f"),(varkosten11[hz] - varkosten21[hz]));
                        //AfxMessageBox(str,MB_YESNO,0);

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v9.umrechnungsfaktor
                                + (varkosten61[ hz] - varkosten91[ hz])
                                + zufallsadd;
						if(mv1berg > 18)
                         energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v9.umrechnungsfaktor
                                + (varkosten61[ hz] - varkosten91[ hz])
                                + zufallsadd;

                    }
                }

                break;
			case 10: //Es liegt die Weide mit 3 Arbeitsgaengen vor
                kostenm.berechne_kostendifferenz( ertragv10, refenergie4,
                        refenergie4, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd, energiedifferenz,verwertung);
				if(mv1berg > 18)
				 kostenberg.berechne_kostendifferenz( ertragv10, refenergie4,
                        refenergie4, gzniedrigmax, gzmittelmax, gzhochmax,
                        gzsehrhochmax, (*ml).streifenmahd,
                        energiedifferenz_berg,verwertung);

                for( hz = 0; hz < gzsehrhochmax; hz++)
                {
                    zufallsadd = ((double) rand() / ((double) RAND_MAX))
                            * 0.000000000001;
                    addorsub = rand() % 2;
                    if( addorsub == 1)
                        zufallsadd = zufallsadd * (-1);

                    if( (*ml).duengung == 0)
                    {

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v10.umrechnungsfaktor
                                + (varkosten41[ hz] - varkosten100[ hz])
                                + zufallsadd;
						if(mv1berg > 18)
						 energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v10.umrechnungsfaktor
                                + (varkosten41[ hz] - varkosten100[ hz])
                                + zufallsadd;
						//str.Format(_T("%.2f"),(varkosten11[hz] - varkosten80[hz]));
                       // AfxMessageBox(str,MB_YESNO,0);

                    }

                    else
                    {

                        //str.Format(_T("%.2f"),(varkosten11[hz] - varkosten21[hz]));
                        //AfxMessageBox(str,MB_YESNO,0);

                        energiedifferenz[ hz] = energiedifferenz[ hz]
                                * v10.umrechnungsfaktor
                                + (varkosten41[ hz] - varkosten101[ hz])
                                + zufallsadd;
						if(mv1berg > 18)
							energiedifferenz_berg[ hz] = energiedifferenz_berg[ hz]
                                * v10.umrechnungsfaktor
                                + (varkosten41[ hz] - varkosten101[ hz])
                                + zufallsadd;

                    }
                }

                break;
            default:
                break;
        }
        vector< double> mgewinn( 101);
        vector< double> mgewinn_berg( 101);

        for( hz = 0; hz < gzsehrhochmax; hz++)
        {
            if( energiedifferenz[ hz] < (DBL_MAX - 1))
            {

                mgewinn[ hz] = (*ml).zahlung + energiedifferenz[ hz];
            } else
            {

                mgewinn[ hz] = DBL_MAX;
            }

			if(mv1berg > 18)
			{
				if( energiedifferenz_berg[ hz] < (DBL_MAX - 1))
					mgewinn_berg[ hz] = (*ml).zahlung + energiedifferenz_berg[ hz];
				else
				{

					mgewinn_berg[ hz] = DBL_MAX;
				}
			}
            //str.Format(_T("%.2f"),energiedifferenz[hz]);
            //AfxMessageBox(str,MB_YESNO,0);

        }
        /*
         AfxMessageBox("Energiedifferenz für GZ 16, 40, 45",MB_YESNO,0);
         str.Format(_T("%.2f"),varkosten11[20]);
         AfxMessageBox(str,MB_YESNO,0);
         str.Format(_T("%.2f"),varkosten11[42]);
         AfxMessageBox(str,MB_YESNO,0);
         str.Format(_T("%.2f"),varkosten11[47]);
         AfxMessageBox(str,MB_YESNO,0);*/

        mgruen.kosten = energiedifferenz;
        mgruen.kosten_berg = energiedifferenz_berg;
        mgruen.gewinn = mgewinn;
        mgruen.gewinn_berg = mgewinn_berg;
        massnamegruenlandliste.push_back( mgruen);
		

    }

//AfxMessageBox("komme bis hinter die Kosten 2",MB_YESNO,0);
    int mod_pixel = 0; //Anzahl an Pixel die für diese Maßnahme erfolgreich modeliert wurden
	//artenqualitaet aq;
    for( n = 0; n < zeilen; n++)
    {
        for( m = 0; m < spalten; m++)
        {
            pixel* pix = neue_matrix[ n][ m];

            int ref = pix->get_gruenlandzahl();

            double gqualitaet = 0;

            if( ref != 0)
            {

                if( (pix->get_feuchte_feucht() != 0)
                        || (pix->get_feuchte_mittel() != 0)
                        || (pix->get_feuchte_trocken() != 0))
                {

                    //für alle Arten und für jede  Maßnahmen
//AfxMessageBox("Vor massnahmenliste",MB_YESNO,0);
                    bool besatz_ok;
                    int l = 0;

                    for( mgi = massnamegruenlandliste.begin();
                            mgi != massnamegruenlandliste.end(); mgi++)
                    {
                        besatz_ok = false;
                        if( ((*mgi).massnahm.grossvieheinheit < 0.4)
                                || ((*mgi).massnahm.grossvieheinheit > 60))
                        {
                            //AfxMessageBox("Bin immer hier",MB_YESNO,0);
                            besatz_ok = true;
                        } else
                        {
                           

                            //AfxMessageBox("Bin immer hier 2",MB_YESNO,0);
                            if( (*mgi).massnahm.mv1massnahme == 1) // bei Ganzjahresstandweide ist der Anteil fest fuer alle Gruenlandzahlen
                            {
                                //AfxMessageBox("Bin immer hier 3",MB_YESNO,0);
                                besatz_ok = true;
                                (*mgi).massnahm.hoehenanteil_hoch = 1 / 3.0;
                                (*mgi).massnahm.hoehenanteil_mittel = 1 / 3.0;
                                (*mgi).massnahm.hoehenanteil_niedrig = 1 / 3.0;
                            } else
                            {

                                if( (ref <= gzniedrigmax)
                                        && ((*mgi).massnahm.grossvieheinheit
                                                <= besatzniedrig))
                                {
                                    besatz_ok = true;
                                    (*mgi).massnahm.hoehenanteil_hoch = (*mgi)
                                            .hoehe_hoch1;
                                    (*mgi).massnahm.hoehenanteil_mittel = (*mgi)
                                            .hoehe_mittel1;
                                    (*mgi).massnahm.hoehenanteil_niedrig =
                                            (*mgi).hoehe_niedrig1;

                                } else
                                {
                                    if( (ref <= gzmittelmax)
                                            && ((*mgi).massnahm.grossvieheinheit
                                                    <= besatzmittel))
                                    {
                                        besatz_ok = true;
                                        (*mgi).massnahm.hoehenanteil_hoch =
                                                (*mgi).hoehe_hoch2;
                                        (*mgi).massnahm.hoehenanteil_mittel =
                                                (*mgi).hoehe_mittel2;
                                        (*mgi).massnahm.hoehenanteil_niedrig =
                                                (*mgi).hoehe_niedrig2;

                                    } else
                                    {
                                        if( (ref <= gzhochmax)
                                                && ((*mgi).massnahm
                                                        .grossvieheinheit
                                                        <= besatzhoch))
                                        {
                                            besatz_ok = true;
                                            (*mgi).massnahm.hoehenanteil_hoch =
                                                    (*mgi).hoehe_hoch2;
                                            (*mgi).massnahm.hoehenanteil_mittel =
                                                    (*mgi).hoehe_mittel2;
                                            (*mgi).massnahm.hoehenanteil_niedrig =
                                                    (*mgi).hoehe_niedrig2;

                                        } else
                                        {
                                            if( (ref <= gzsehrhochmax)
                                                    && ((*mgi).massnahm
                                                            .grossvieheinheit
                                                            <= besatzsehrhoch))
                                            {
                                                besatz_ok = true;
                                                (*mgi).massnahm
                                                        .hoehenanteil_hoch =
                                                        (*mgi).hoehe_hoch3;
                                                (*mgi).massnahm
                                                        .hoehenanteil_mittel =
                                                        (*mgi).hoehe_mittel3;
                                                (*mgi).massnahm
                                                        .hoehenanteil_niedrig =
                                                        (*mgi).hoehe_niedrig3;

                                            } else
                                                besatz_ok = false;
                                        }
                                    }

                                }
                            }
                            if( besatz_ok == true)
                            {
                                if( ((*mgi).gewinn[ ref] < (DBL_MAX - 1))
                                        && (pix->get_hoehenlage() == 0))
                                {
                                    besatz_ok = true;
                                } else
                                {
                                    besatz_ok = false;
									if((*mgi).massnahm.mv1massnahme > 20)
									{
										if( ((*mgi).gewinn_berg[ ref]
												< (DBL_MAX - 1))
												&& (pix->get_hoehenlage() == 1))
										{
											besatz_ok = true;
										} else
											besatz_ok = false;
									}
                                }
                            }
                        }

                        if( ((pix->get_bearbeitung() == 0)
                                && ((((*mgi).massnahm.verfahren_nr == 2)&&((pix->get_hoehenlage() == 0)||((pix->get_hoehenlage() == 1)&& ((*mgi).massnahm.mv1massnahme > 20))))
                                        || (((*mgi).massnahm.verfahren_nr == 3)&&((pix->get_hoehenlage() == 0)||((pix->get_hoehenlage() == 1)&& ((*mgi).massnahm.mv1massnahme > 20))))
                                        || ((*mgi).massnahm.verfahren_nr == 1)
										|| (((*mgi).massnahm.verfahren_nr == 8) &&((pix->get_hoehenlage() == 0)||((pix->get_hoehenlage() == 1)&& ((*mgi).massnahm.mv1massnahme > 20))))))
                              || ((pix->get_bearbeitung() == 1)
                                    && (((*mgi).massnahm.verfahren_nr == 4)
                                        || (((*mgi).massnahm.verfahren_nr == 5)&&((pix->get_hoehenlage() == 0)||((pix->get_hoehenlage() == 1)&& ((*mgi).massnahm.mv1massnahme > 20))||((*mgi).massnahm.grossvieheinheit < 40)))
										|| (((*mgi).massnahm.verfahren_nr == 10)&&((pix->get_hoehenlage() == 0)||((pix->get_hoehenlage() == 1)&& ((*mgi).massnahm.mv1massnahme > 20))||((*mgi).massnahm.grossvieheinheit < 40)))))
                              || ((pix->get_bearbeitung() == 2)
                                     && (((*mgi).massnahm.verfahren_nr == 6)
                                        || (((*mgi).massnahm.verfahren_nr == 7)&&((pix->get_hoehenlage() == 0)||((pix->get_hoehenlage() == 1)&& ((*mgi).massnahm.mv1massnahme > 20))))
                                        || (((*mgi).massnahm.verfahren_nr == 9)&&((pix->get_hoehenlage() == 0)||((pix->get_hoehenlage() == 1)&& ((*mgi).massnahm.mv1massnahme > 20)))))))


                        {
                            if( besatz_ok != false) //falls eine Beweidung vorliegt darf die Anzahl der Tiere nicht die fuer die Gruenlandzahl vorgeschriebene hoechstmenge uebersteigen!
                            {
                               // AfxMessageBox("Vor der Arten schleife",MB_YESNO,0);
                                double artenfaktor = 0;
                                int artenindex = 0;
                                int artenvork = 0;
                                int artpos = 0;
                                vector < artenqualitaet > artenqualvec;
                                //qualitaet= 0;

                                //for (int a = artlist.begin(); a!= artlist.end(); a++)
                                for( int b = 0; b != artnr; b++)
                                {
                                    //artqualitaet = 0;
                                    if( (*mgi).massnahm.tierart != 0
                                            && (*mgi).massnahm.grossvieheinheit
                                                    < 90)
                                    {
                                        artenfaktor = (*mgi).faktorliste[ b];
                                        //artenindex++;
                                    }

                                    if( "Schmetterling"
                                            == artlist[ b]->get_gruppe())
                                    {
                                        //	AfxMessageBox("berechne eine Qualitaet 1",MB_YESNO,0);
                                       if( vorkommen[ artenvork][ n][ m]
                                              == true)
                                        {
                                            artqualitaet =
                                                    oeko.habitatqualitaet(
                                                            artlist[ b], (*pix),
                                                            (*mgi).massnahm,
                                                            (*mgi).gliste,
                                                            artenfaktor);

										 } else
											  artqualitaet = 0;
                                        artenvork++;
                                    } else
                                    {
                                        artqualitaet = oeko.habitatqualitaet(
                                                artlist[ b], (*pix),
                                                (*mgi).massnahm, (*mgi).gliste,
                                                artenfaktor);
                                    }
                                    // Es werden die Qualitaet für alle Arten gespeichert, ist die min Qualitaet nicht erreicht, wird sie auf Null gesezt
                                    //str.Format(_T("%d"),artlist[b]->last_egg_dep);
                                    //AfxMessageBox(str,MB_YESNO,0);
                                    artenqualitaet aq;
                                    //aq = new artenqualitaet;
                                    aq.art = artlist[ b];
                                    if( artqualitaet >= (minqualitaet[ b]))
                                    {
                                        aq.qualitaet = artqualitaet;
                                        qualitaet = qualitaet + artqualitaet;
                                    } else
                                    {
                                        aq.qualitaet = 0;
                                        //artqualitaet = 0;
                                    }

                                    artenqualvec.push_back( aq);
                                    artpos++;
                                }

   //umbedingt wieder reinholen!!!!!!                           
								// if( (qualitaet != 0) && besatz_ok)
								if( besatz_ok)
                                {

                                    vector < gruenlandqualitaet > gruenq;
                                    masspixelergeb mapg;
                                   // mapg =  masspixelergeb;
                                    mapg.artenq = artenqualvec;
                                    if( (*pix).get_hoehenlage() == 1) //Der Wert für den Berg muss geholt werden
                                    {
                                        mapg.kosten =
                                                (*mgi).kosten_berg[ ref];
                                        mapg.gewinn =
                                                (*mgi).gewinn_berg[ ref];
                                    } else // Das Pixel liegt im Tal
                                    {
                                        mapg.kosten = (*mgi).kosten[ ref];
                                        mapg.gewinn = (*mgi).gewinn[ ref];

                                    }
                                    for( j = (*mgi).gliste.begin();
                                            j != (*mgi).gliste.end(); j++)
                                    {
                                        double z = 0;
                                        double gruenqualitaet = 0;
                                        bool ph, pt;
                                        if( (*pix).get_hoehenlage() == 0)
                                        {
                                            ph = false;
                                            pt = true;
                                        } else
                                        {
                                            ph = true;
                                            pt = false;
                                        }
                                        if( (*(*j)).hoch == ph
                                                || (*(*j)).tief == pt)
                                        {
                                            if( ((*pix).get_feuchte_feucht())
                                                    != 0)
                                                z = z + 1;

                                            if( ((*pix).get_feuchte_mittel())
                                                    != 0)
                                                z = z + 1;

                                            if( ((*pix).get_feuchte_trocken())
                                                    != 0)
                                                z = z + 1;

                                            double nf = 1 / z;
                                            gruenqualitaet =
                                                    ((*(*j)).feucht
                                                            * (*pix)
                                                                    .get_feuchte_feucht()
                                                            * nf)
                                                            + ((*(*j)).frisch
                                                                    * (*pix)
                                                                            .get_feuchte_mittel()
                                                                    * nf)
                                                            + ((*(*j)).trocken
                                                                    * (*pix)
                                                                            .get_feuchte_trocken()
                                                                    * nf);
                                        }
                                        if( gruenqualitaet > 0)
                                        {
                                            gruenlandqualitaet gruenqual;
                                            gruenqual.gqualitaet =
                                                    gruenqualitaet;
                                            gruenqual.gruenlandID = (*(*j))
                                                    .gruenlandID;
                                            gruenq.push_back( gruenqual);
                                        }

                                    }
                                    if( gruenq.size() != 0)
                                        sort( gruenq.begin(), gruenq.end(),
                                                sortfunction);
                                    else
                                    {
                                        gruenlandqualitaet gruenqual;
                                        gruenqual.gqualitaet = 0;
                                        gruenqual.gruenlandID = 0;
                                        gruenq.push_back( gruenqual);
                                    }
                                    mapg.matrix_i = pix->get_matrix_i();
                                    mapg.matrix_j = pix->get_matrix_j();
                                    mapg.pixelID = pix->get_pixelID();
                                    mapg.m = (*mgi).massnahm;
                                    //(*mapg).gq = gruenq;

                                    massnahmenergebvector[ l].push_back(
                                            mapg);
                                    gqualitaet = qualitaet + gqualitaet;
                                    qualitaet = 0;

                                    //h++;

                                }

                            }
                        }
                        l++;
                    }

                }

               // AfxMessageBox("Komme hinters Pixel",MB_YESNO,0);
            }
        }
    }

    //aufräumen nicht vergessen!
    //AfxMessageBox("Nach der Modelierung",MB_YESNO,0);

    for( j = gliste.begin(); j != gliste.end(); j++)
    {
        delete *(j);
    }

    mat.delete_pixel_matrix( neue_matrix, zeilen, spalten);
    //return massnahmenergebvector;

}

double modell::berechneFlaeche(vector<artenqualitaet> &aq, vector<double> &gewichte)
{
	double erg = 0;
	for(int i=0; i<aq.size(); i++)
	{
		erg += aq[i].qualitaet*gewichte[i];
	}
	return 6.25*erg;
}