AgentFarmHousehold.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
//
//  Thomas Berger (main author), Pepijn Schreinemachers, and Thorsten Arnold
//
//
//  Hohenheim University (490d)            
//  Professorship for Land Use Economics in the Tropics and Subtropics
//
//  May not be distributed without permission by main author
//
//  File:       AgentFarmHousehold.h (formerly agentF.h)
//
//  Contents:   Header of farm-household class that is derived
//              from the basic class "agent"
//
//
//------------------------------------------------------------------------------


#ifndef _AgentFarmHousehold_h
#define _AgentFarmHousehold_h

#include "Agent.h"

#ifdef LP_OLD
        #include "simplx9.h"
#else
        //#include "AgentSolution.h"
        //#include "AgentProblem.h"
        #include "MipHandler.h"
#endif /*LP_OLD*/

#include "MatrixDouble.h"
#include "AgentParcelList.h"
#include "AgentHouseholdList.h"
#include "AgentLivestockList.h"
#include "PopulationNetworkSegment.h"
#include "AgentParcelGridCellInterface.h"
#include "TimeHandlerClass.h"

class IrrigationMethodSector;


class agentF : public agent
{       public:
        
//------------------------------------------------------------------------------------

        virtual void    setSegPtr(segment*);

        virtual int             getNumberOfParcels();
        virtual void    setNumberOfParcels(int);
        virtual int             getNumberOfIrrigableParcels();//special treatment for Ghana
        virtual int             get_segment();
        virtual void    set_segment(int);
        virtual int             get_innov();
        virtual int             get_erwart();
        virtual void    set_erwart(int);
        virtual int             getCluNum();
        virtual int             getPopNum();
        virtual int             getFstID();
        virtual int             get_farbe();
        virtual void    set_farbe(int clr56);

   virtual int getFirstInflowID();

        virtual double get_b_wert();//Betriebswert
        virtual int             getSolvedLP();

        virtual int    get_FamAK();
        virtual void   set_FamAK(int);
        virtual int    get_FrAK();
        virtual void   set_FrAK(int);
        virtual double get_EK();
        virtual void   set_EK(double);
        virtual double get_liq();
        virtual void   set_liq(double);
        virtual double get_akt();
        virtual void   set_akt(double);
        virtual double get_FK();
        virtual void   set_FK(double);
        virtual double get_entfk();
        virtual void   set_entfk(double);
        virtual double get_werts();
        virtual double get_durchsDB();
        virtual int    get_migr();//migration decision

        virtual int    checkNumPlots();
        virtual int             getNumPlotsInClass(int);
        virtual int             getNumPlotsInSoilType(int soilType);
        virtual int    get_parzellen(int);//Parameter Typ
        virtual void   set_parzellen(int, int);//Parameter Typ, Anzahl
        virtual int    get_hof_x();
        virtual void   set_hof_x(int);
        virtual int    get_hof_y();
        virtual void   set_hof_y(int);
        virtual void   set_bflaech_verpachtet(int, int);
        virtual void   make_bflaech(int c, int r, int typ, int fst, double dst);
        virtual int    get_bflaech_anzahl();
        virtual void   bflaechen_printOnScreen();
        virtual void   bflaech_einfuegen(parzelle*);

        virtual double getEtaOfAgent(){return etaOfAgent;}
        virtual double getTotalIrrigationWaterApplied() {return totalIrrigationWaterApplied;};
        
//------------------------------------------------------------------------------------


        virtual int get_sym_obj(int);//Parameter Nr
        virtual void set_sym_obj(int, int);//Parameter Nr, Flag
        virtual void makeSymObj(int oID);
        virtual int lookSymObj(int oID);
        virtual void copyCoeffSymObjMILP();
        virtual void printSymObjsOnScreen();

        virtual int get_binv_size();
        virtual int get_binv_anz_obj();
        virtual char* get_binv_acc(int i);
        virtual void set_binv_acc(int i, char* chr);
        virtual int get_binv_code(int i);//Parameter Row
        virtual double get_binv_ask(int i);//Parameter Row
        virtual double get_binv_anz(int i);//Parameter Row
        virtual int get_binv_age(int i);//Parameter Row
        virtual void set_binv_age(int i, int age);//Parameters Row, age
        virtual double get_binv_shareEC(int i);//Parameter Row
        virtual void set_binv_shareEC(int i, double shr);//Parameters Row, share
        virtual double get_binv_rateDC(int i);//Parameter Row
        virtual void set_binv_rateDC(int i, double rat);//Parameters Row, rate
        virtual void binvest_vergroessern();//erhoeht die Speicherplatzgroesse
        virtual void inventarisieren(char* acc, int oID, double pPr, double siz, double ssf, double iDC, int age);
        virtual void deinventarisieren(int);// Uebergabe: Inventarnr.
        virtual void binvest_ausschreiben();
        virtual void binvest_writeToStream(FILE* strm);
        virtual int getObjRowForCol(int cLP);//neu 2004 gibt Obj.nr in Invest_matrix
        virtual int getObjCodeForCol(int cLP);//neu 2004 gibt Objektcode zurueck
        virtual int getObjRowForCode(int code);//neu 2004
        virtual int getCapRowForCode(int code);//neu 2004 liefert Kapazitaetsnr.
        virtual int get_n_dauer(int code);//neu 2004 ermittelt Nutz.dauer
        virtual int getRegRowForCode(int code);//Nr. im Dauerkulturenregister ermitteln

        virtual void checkIfAgentHasInfrastructureProjects();
        
        //virtual int get_klasse(int code);//substitute ## soil 
        virtual int getSoilType(int objID);

        virtual double get_lohn();//ermittelt ausserlandwirtschaftliches Einkommen
        virtual nutz get_nutz_info(int);

        virtual void updatePerennialsRegistry();
        virtual int makeEntryInPerennialsRegistry(int objID, int colLP);
        virtual void computeIndividualObjectCoefficients(int objectID, double sizeHa, int age, int idxPermCrops, double interest);

        virtual void dauerkultur_austragen(int soilType, double sizeHa);//## soil rename function
        virtual double get_fruehe_produktionskosten(int);
        virtual double getHectaresOfPermanentCropsOnSoilType(int soilType, int);

        /* TODO 2 -oBerger -cImplement : these 3 functions need to be made generic,
                currently they are Chile-specific */
        virtual void bflaech_obst_belegen(double, double);//substitute ## soil
   // ... Additional string passed for error messages   
        virtual void blockParcelsWithPermanentCrops(int soilType, double existingHa, double deltaHa, string outputStr);


        virtual void bflaech_forst_belegen(double, double);//substitute ## soil
        virtual void forst_zaehlen();//zaehlt Parzellen der Bodenklasse "Forst" //substitute ## soil

//------------------------------------------------------------------------------------


        virtual void makePriceExpectation(); 
        virtual void makeWaterSupplyExpectationYearly();
        virtual void makeWaterSupplyExpectationInMonth(int m);
        virtual void makeWaterDemandExpectationYearly();
//Arnold2008_0812 NOT SUITABLE FOR DYNAMIC PRECIPITATIOM
// --> naivly set to last-year's precipitation
//  ... (or, if the time continuum is broken, then to real precipitation -- which is
//  ...  unknown, even if river flows are rather well known! )
        virtual void makeWaterDemandExpectationInMonth(int m);
        virtual void makeYieldExpectationsForCropWat();
        virtual void initializeYieldExpectationsForCropWat();


//Arnold2008_0812 NOT TESTED
   virtual void estimateEffectivePrecipitationForFullYear(TimeHandler& th_notChanged,    MatrixDouble& vectorPrecipitation,    MatrixDouble& agentsEffectivePrecipitation );
//Arnold2008_0812 NOT TESTED         
   virtual void copyEffectivePrecipitationInMonth(int m, const MatrixDouble& vectorOfMonthlyCropEffectivePrecipitation, MatrixDouble& agentsEffectivePrecipitation);

/* FOR REFERENCE ONLY (see bellow declaration!)
        //CHECK: yield expectations
        MatrixDouble expCropWaterYields;
        //CHECK: actual yields
        MatrixDouble actCropWaterYields;

        //CHECK: expected irrigation water demands
        MatrixDouble expCropWaterIrrDmds;  // DIMENSION: numActivities X numMonths
*/


        virtual void makeYieldExpectationsForTspc();//renamed from <makeYieldExpect>
        virtual void initializeYieldExpectationsForTspc();//renamed from <initYieldExpect>
        virtual void initPlotsInNRUs();
        
        virtual int pacht_ueberlegen(); //Ueberlegungen ueber Pacht/Zupacht
        virtual double hole_q_B(int);//liefert Boden-Schattenpreis
        virtual double hole_q_W(int);//liefert Wasser-Schattenpreis
        virtual double hole_volB(int);//liefert erwartetetes Brutto-Water
        virtual void forderung_speichern(int, p_gebot* f);
        virtual void forderung_holen(int typ, p_gebot* f);
        virtual void forderung_loeschen(int typ);//loescht eine gespeicherte Forderung
        virtual void matrix_forderung_loeschen();
        virtual double get_zus_TK();
        virtual void set_zus_TK(double);

//------------------------------------------------------------------------------------


        virtual double investPlanOSL();
        virtual double producPlanOSL();
        virtual double consumPlanOSL();
        
        // ... functions to avoid LP_OLD branching 
   virtual int getNNrowsInternal();
        virtual int getNNcolsInternal();
        virtual int getNumColsInternal();
   virtual double getActualTotalGrossMargin();


        virtual void inv_leistungen();  //traegt die Leistungen der Investitionsobjekte in die Kapazitaeten ein
        virtual void rhs_Runden();//rundet Nachkommastellen

        virtual double get_kapazitaeten(int);
        virtual void set_kapazitaeten(int, double);
        virtual double get_schattenpreise(int);
        virtual void schattenpreise_speichern();
        virtual void schattenpreise_wiederherstellen();

        virtual void updateAgentZRow();//formerly 'kapaz9()'
        virtual void updateStartPeriodRHS();//formerly 'kapaz9()'
        virtual void updateEndOfPeriodRHS();//formerly 'kapaz9()'
        virtual void copyInvPCropsRHS();//formerly 'teilb_innovationen()'
        
        virtual int copyLPdataInvMode(int);//subsitute
        virtual int copyLpDataInInvestmentMode(int isIntegerProblem);
        
        virtual void copyAvailablePermanentCropsInInvestmentMode(int availPCropsIdx);//availPermCrops
        virtual void copyExistingPermanentCropsInInvestmentMode(int agentRegistryIdx, int lpCol, int lpRow);//dkult_reg
        virtual void copyAllOtherAvailableObjectsInInvestmentMode(int invObjIdx);//investmeth
        virtual void copyNewLivestockInInvestmentMode(int invObjIdx);
        virtual void copyExistingLivestockInInvestmentMode(int objectID);

        virtual int copyLPdataPrdMode(int);//subsitute
        virtual int copyLpDataInProductionMode(int isIntegerProblem);
        
        virtual void copyExistingPermanentCropsInProductionMode(int agentRegistryIdx, int lpCol, int lpRow);//dkult_reg
        virtual void copyExistingLivestockInProductionMode(int objectID);

        virtual void copyExpectedWaterDemandsIntoMILP();
        virtual void copyExpectedYieldsOfAnnualCropsIntoMILP();//refactoring of <copyYldExpMILP>
        
        virtual int copyLPdataConMode(int ipr);
        virtual void copyConsCoeff(double hhEgy);
        virtual void modifyProductionSolution(int num, int*& cols, double*& values);
        virtual void setProductionSolutionColumn(double va, int colLP);

#ifdef LP_OLD

        virtual double solveLinPrbOSL(int savePrim, int saveDual);
        virtual double solveIntPrbOSL(int savePrim, int saveDual, int& forSol);

        virtual void makeNewPrbOSL();
        virtual void freeNewPrbOSL();
#else
        //some functions that were formerly handeled by "mpPrbl"
        virtual void changeObjFunc(double*& objF, int oSta, int oEnd);
        virtual void fixLaborBinar(double femLab, double malLab);
        virtual void fixProducVars();
        virtual void changeElemMtx(int num, int*& rows, int*& cols, double*& elms);
        virtual void setToEEConstr(int rLP, double value);      
        virtual void switchOffFineTune();
        virtual void switchOnFineTune();

        //formerly implemented in class mpPrbl
        virtual int identCrAcForCol(int colLP, int& aID, int& nru);
#endif

//------------------------------------------------------------------------------------

        //virtual void initializeEdicIrrigationModel(void);//Tbe 080220
        //virtual void calculateIrrigationSuppyQuantityByCrop(int m);//Tbe 080220
        virtual void set_IPGvec(void);
        //virtual double computeEtaOnIrrigatedArea(IrrigationMethodSector* sectorPointerToIrrigationMethods);//substitute
        virtual double computeAverageOnFieldIrrigationEfficiency(IrrigationMethodSector* sectorPointerToIrrigationMethods);//Tbe 080220

        //virtual double irrigateCropsUsingPriorityGroupsRule(int mTot);//substitute
        virtual double irrigateCropsByPriorityGroups(int month);//Tbe 080220

        //virtual void calculateYieldsEdic();//substitute
        virtual void computeCropWaterYields();//Tbe 080220

        //virtual void setOutputOfPerennialCropsToZero();//substitute
        //virtual void modifyPerennialsEdic();//substitute
        virtual void setOutputOfAllCropsToZero();//Tbe 080220

        //virtual void computeYieldAndIncomeAndCostsFromIrrigationActivities(const MatrixDouble& colsForObjs);//substitute
        virtual void applyYieldReductionFactorsAndUpdateLpSolution();//Tbe 080220

        virtual double get_N_i(int);
        virtual double get_WPa_i(int);
        virtual void set_WPa_i(int, double);//Parameters Month, Volumn
        virtual void waterrights_eintragen(int, double);//Zufluss-Nr. und Anteil
        virtual void hole_durchs_waterrights(w_rechte*);//... je Parzelle 
        virtual void waterrights_austragen(w_rechte*);//traegt WaterRights aus
        
        //virtual void createCropLookupAndResetCropYieldInfo();//substitute
        //virtual void compareCropLookupWithCropYieldInfo();//substitute
        virtual void createDataForCropWaterModule();//Tbe 080220

        //virtual double calculateIrrigationDemandByIrrigMethod(int month);//substitute 
        virtual double aggregateIrrigationWaterDemandsByIrrigationMethod(int month);//Tbe 080220, renamed from <meth_D_berechnen9>

        virtual double receiveNetInflows(int month, int = true);//Flag (save sector values yes/no) //renamed from <N_berechnen>
        //      virtual void Extra_berechnen9(int);//vorlaeufig ungenutztes Betriebswasser     //erw. EDIC-Modell
        virtual double receivePlantWaterDemandsSatisfied(int month);//renamed from <D_sat_berechnen>
   virtual double receivePlantWaterDemandsSatisfied(int month, double Ueb_j_tmp);

//------------------------------------------------------------------------------------


        virtual void makePlantYields();//formerly 'ertraege_berechnen()'

        virtual double bodenvermoegen_bestimmen();//auf Grundlage von Schattenpreisen
        virtual void computeIncome();//formerly "einkommen_berechnen()"
        virtual double computeCashConsumption();
        virtual double vermoegen_umschichten(w_rechte*);//liefert Verkaufserloes
        virtual int betriebsaufgabe_pruefen(double);//Faktorentlohnung
        virtual double abandonAllWaterAndLandResources(w_rechte*);
        virtual double abs_tilg_berechnen(double&);//liefert Tilgung zurueck
        virtual double computeTransportCosts();
        virtual double computeFarmFixCosts();

        virtual void addHHmember(int age, int sex, int head, int career);
        virtual void makeHeadOfHH(int sex);
        virtual void updateAgeOfMembers();
                
        virtual void addUnitLstck(int type, int age);
        virtual void updateOffspOfLstck();
        virtual void updateAgeOfLstck();

        virtual void updateSalesOfLivestock();
        virtual void updateAges();
        virtual double updateIdleLsInBinvest(MatrixDouble& lsIdle);
        virtual double updateSoldLsInBinvest(MatrixDouble& lsSold);
        virtual void incrLiqStartPeriod(double amount);
        virtual void incrLiqEndOfPeriod(double amount);
        
//------------------------------------------------------------------------------------


        virtual void writeAgtLandData(FILE* stream0);
        virtual void writeAgtWaterData(int m);

        virtual void writeExpectedMarketPriceData(FILE* strm);
        virtual void writeExpectedWaterSupplyData(FILE* strm);
        virtual void writeExpectedCropWaterData(FILE* strm);

        //Function writes the first lines of the agent - which is needed for every output file to identify agents
        virtual void writeAgtIdEntry(FILE* stream);
        virtual void writePfmPrdData(FILE* stream0, FILE* stream1);
        virtual void writeCapRHSData(FILE* stream);
        
        virtual void printOnScreenHH();
        virtual void printOnScreenWaterRights();
        virtual void bnummer_anpassen(int);

        virtual void printOnScreen_crpMixClass();
        
        virtual void printOnScreen_crpMixClass(int cnt);
        virtual void printOnScreen_crpMixWater();
        virtual void printOnScreen_crpMixWater(int cnt);

        virtual void printOnScreenProduction();
        virtual void writeToFileProduction(ofstream& out);
        virtual void printOnScreen_AllInfo(int soilC, int cnt);
        virtual void printOnScreen_bflaech(void);
        virtual void printSymbolicObjects();

        virtual void printOnScreenLv();
        virtual void printOnScreen2();
        //Arnold2006_8
        virtual void printOnScreenWater();
        virtual void printOnScreenCropMatrix();

   //virtual void writeToFileCropMatrix();//substitute
        virtual void writeAllCropWaterDataToFile();//Tbe 080220

        //Arnold2006_12
        virtual void writeAllParcelsToFile(ofstream& out);
        //Arnold2006_62
        virtual void writeWaterInfoToFile(ofstream& out);

//------------------------------------------------------------------------------------

        //returns 0 of no activity within soil class, 1 otherwise
        virtual int checkCropsInClass(int i);
        //virtual void checkCropsInClass(crpMixClass*& cmClass);
        
        //Arnold2006_36
        virtual void allocateActivitiesInSpace(void);
        // For coupling and spatially active runs:
        virtual void  allocateSpatiallyIrrigationWaterToCropMixClass(int thisMonth);

        //Arnold2008_08 TO BE ERASED
        //virtual void updateParcelToLandscape(Content cont);
        //for monthly: takes REAL month
        //virtual void updateParcelToLandscape(Content cont, int m);
        virtual void updateIrrigWaterCropMixClass2Parcels(int mTot);

   //for monthly: takes REAL month
        virtual void copyContent_Water2Parcels(int mTot);
   
   virtual void copyContent_Landscape2Parcels(Content cont);
    virtual void copyContent_Landscape2Parcels(Content cont, bool flag_fixCopyToCell);
   virtual void copyContent_Landscape2Parcels_monthly(Content cont, int m);
   virtual void copyContent_ParcelToLandscape(Content cont);
   virtual void copyContent_ParcelToLandscape_monthly(Content cont, int month);
   
   // ... for testing
   virtual double getMeanOfAllParcels(Content cont);


        //Arnold2006_45 also clears parcel lists!
        virtual void resetAllParcels_toNotUsed(void);

        //Arnold2006_55
        // checks if all parcels in crpMixClass are set to "get_hasCrop() == true"
        virtual void checkIfTrue(bool isTrue);
        virtual void addLanduseToColumnOfMatrix(MatrixDouble& matrixOfCatchmentLandUses, int uaID);

        virtual void checkActivityIDconsistent(int a, string functionName);
        virtual double getActivityArea(int a);
        
//------------------------------------------------------------------------------------          



        investart* investmeth;//Pointer to info on investment goods <invest_matrix>
        int* inv_anz_ptr;               //Zeiger auf die Objektanzahl einer Invest_matrix
        double* rateLC_ptr;     //Zeiger auf den FK-Zinssatz eines Segments
        double* rateSC_ptr;     //Zeiger auf den kurzfristgen FK-Zinssatz eines Segments
        double* rateSD_ptr;     //Zeiger auf den EK-Zinssatz eines Segments
        double* shareEC_ptr;    //Zeiger auf den Eigenfinanzierungsanteil eines Segments
        double* bonus_ptr;      //Zeiger auf direkte Einkommenstransfers fuer ein Segment
        double* sunkcost_ptr;//Zeiger auf den Anteil der wiederzugewinnenden Kosten
        double* sog_ptr;                //Zeiger auf den "Sogfaktor"
        double* opp_ptr;     //neu 2003 Zeiger auf "Opplohn"
        MatrixDouble* dkulturen_ptr;//Pointer to matrix <verfuegb_dkulturen> //substitute

#ifdef LP_OLD
        agentF(int agid, int scid, int skid, int ppid, int clid, int nwid, int fstd, int numP, int seg, int erw);
#else



        //default copy constructor
        //default assignment operator
        agentF(int agid, int scid, int skid, int ppid, int clid, int nwid, int fstd, int numP, int seg, int erw, MipHandler* globalProblemHandler_);
#endif /*LP_OLD*/

        virtual ~agentF();
        virtual void deallocYieldExp(); 

//------------------------------------------------------------------------------------          

#ifndef LP_OLD
        private:

        MipHandler* globalProblemHandler;
        ProblemDescription* specialMipIndices;
        AgentProblem* specificProblem;
        AgentSolution investmentSolution;
        AgentSolution productionSolution;
        AgentSolution consumptionSolution;


        virtual void upateMipHandlerAgentParam();
#endif /*LP_OLD*/

        protected:


        int seg_nr;        //Nummer des Betriebssegments (Innovationsfaehigkeit)
        int innov;         //Nr. des Innovationskommunikations-Netzwerks (=Betriebsliste)
        int erwart;        //Art der Preiserwartungsbildung
        int popID;     //population ID
        int cluID;     //cluster ID
        int fstID;     //farmstead ID in maps
        int farbe;     //color of plots in maps (max. 56 colors)

//------------------------------------------------------------------------------------   


        int fl_anzahl;
        int* parzellen;
        coord hofflaeche;
        p_liste bflaech;     
        ls_list herd;        
        hh_list household;   
        int famAK_anzahl;
        int frAK_anzahl;

        MatrixDouble wr;
        // DIMS: (numInflows X 2)
        //  col 0: zuf    ID for inflow
        //  col 1: anz    quantity

        investdef* binvest;     //Zeiger auf das Inventar-Array
        int binv_anz;              //Anzahl der inventarisierten Objekte
        int binv_size;             //Speicherplatzgroesse
        MatrixDouble dkult_reg; //enum columnsInPermamentCropsRegistry, Matrix (Register) der eigenen Dauerkulturen
        segment* segPtr;     //Pointer to segment investment data
        int** sym_obj;                  //Pointer to symbolic objects
        
//------------------------------------------------------------------------------------


        double afa;
        double aktiva;
        double arbeitseinsatz;
        double bodenentlohnung;
        double cashflow;
        double durchsDB;
        double eigenkapital;
        double einkommen;
        double entfernungskosten;//Transportkosten fuer die Eigentumsflaechen
        double entnahmen;
        double fremdkapital;
        double tilgung;
   //Arnold2008_0812  Changed from totalIrrigArea, to distinguish from "irrigable" which is different
        double totalIrrigatedArea;      //monthly irrigated area, formerly betr_Wert
        double kapitaleinsatz;
        double shortTermDeposits;
        double liqMeans;
        double liqMeansPreviousPeriod;
        double liqMeansUsedForInvestment;
        double equityCapitalPreviousPeriod;
        double debtCapitalPreviousPeriod;
        double pacht;
        double relEntl;
        double wertschoepfung;
        double zinskosten;
        double zusaetzlicheTK;//durch Pachtaktivitaeten entstandene Transportkosten

        double inCashEarn; //Net cash earnings from MILP
        double inKindEarn; //Net in-kind earnings from MILP
        double apprAssets; //Appreciation of durable assets
        double savingOfHH; //Savings of household
        double extraConHH; //Extra consumption

//------------------------------------------------------------------------------------   

        //information on yields of water activities actually selected (uses cropLookup,  cols: Months)
        //MatrixDouble cropYieldInfo;//contents of cropYieldInfo defined in enumYieldInfo //substitute
        //int lengthCropYieldInfo;// number of watetr activities actually selected //substitute
        //int* cropLookup; //substitute

        MatrixDouble cropWaterData;// using <enumYieldInfo>

        //information on water deficits for selected water activities, (effectiveRainfall + irrig)  / Plant Water Demand
        //(uses cropLookup,  cols: Months)
        //MatrixDouble waterDeficitByActiveCropAndMonth;//substitute
        MatrixDouble waterDeficitsOfCropsAsMonthlyKR;//Tbe 080220 selected crops, irrigated and rainfed

        //Matrix of monthly water demands[absolute value]
        //MatrixDouble irrWaterDemandGroup;//substitute
        MatrixDouble irrigationWaterDemandsPerPriorityGroup;//Tbe 080220

        //Percentage of irrigation water demand that was served
        //... in [1/1], from interval [0.0 , 1.0]
        MatrixDouble percentageIrrigatedPerPriorityGroup; //Tbe 080220

        // Actual irrigation water given to each HydroActivity
        //... total water supplied to an activity, in l/sec times area
        MatrixDouble irrigationWaterSuppliedToCrops;//Tbe 080220 (actualHydro x months)

        double etaOfAgent;
        double totalIrrigationWaterApplied; // total irrigation water in current month

        //Arnold2006_19
        // Making code spatially explicit: LP info related to WASIM
        // data structure for crop mix per soil class
        // Dimensions: KLASSEN(), which should be an equivalent to NRU in TSPC-Model!
        // Info on cropping activities within this class in int* and double*;
        // dimension of these vectors is determined by counting
        // bprod.umf[lps]>MINUMFANG()
        crpMixClass* cropMixAgent;

//------------------------------------------------------------------------------------


        double* D_i;            
        double* D_sat;          
        // expected net  water supply
        double* erw_N_i;        
        double* N_i;            
        double* erw_Ext_i;      
        double* Ext_i;
        double* WPa_i;
        double* S_i;//renamed from <Initial_i>     
        
        MatrixDouble expCropWaterYields;
        MatrixDouble actCropWaterYields;

        MatrixDouble expCropWaterIrrDmds;

//------------------------------------------------------------------------------------


        caYld** expYlds;        
        caYld** actYlds;

//------------------------------------------------------------------------------------

        double* erw_preise;                     //expected prices, used to initialize objective fucntion coefficients
        double* varsRHS;                                //the agent's ressources (Right Hand Side)
        double* varsLHS;                                //used capacities of ressources (Left Hand Side)
        double* schattenpreise;         //shadow prices
        double* alte_spreise;           //old shadow prices     
        MatrixDouble ford_bak;          //Matrix to save minimal asking prices
        int lock;                                               //blockiert weitere Investitionen bei Liquiditaetsproblemen
        int migr;                                               //migration decision -1 illiquidity -2 voluntary
                                                                                //-3 deceased -4 no labor force -5 no adult labor force
        int solvedLP;                                   //forced solution (default 0, inv 1, prd 2, con 3)      
        MatrixDouble mEntries;          //MatrixDouble with information for "forced" solution

#ifdef LP_OLD
        l_vektor bprod;//Loesungsvektor (Umfaenge, Zielfunktionskoeff., Zielwert)
#endif

        int numChangedElems;   
        int* idxRow;   
        int* idxCol;   
        double* matEls;

        //}@
//------------------------------------------------------------------------------------
};


/* TODO 5 -oBerger -cImplement : this is for later, with more time */
//class PermanentCropsOfAgent 
//{     //auxiliary class, everything public
//public:
//
//      double investmentObjectID;                      //formerly 17 
//      double purchasePrice;                           //formerly 0  
//
//      double currentCropYield;                        //formerly 15
//      double currentVariableCosts;            //formerly 16
//      double currentPreHarvestCosts;  //formerly 3
//
//      double futureCropYield;                         //formerly 1
//      double futureVariableCosts;             //formerly 2
//      double futurePreHarvestCosts;           //formerly 9
//
//      //current labor demands
//      MatrixDouble currentLaborDemands;       //formerly 4, 7, 8
//
//      //future (average) labor demands
//      MatrixDouble futureLaborDemands;                //formerly 10, 13, 14
//
//      //current machinery demands
//      MatrixDouble currentMachineryDemands;//formerly 5, 6
//
//      //future (average) machinery demands
//      MatrixDouble futureMachineryDemands;//formerly 11, 12
//
//      ///constructor
//      PermanentCropsOfAgent()
//      {       investmentObjectID - 1;         
//              purchasePrice = 0.0;                    
//
//              currentCropYield = 0.0;         
//              currentVariableCosts = 0.0;     
//              currentPreHarvestCosts = 0.0;
//
//              futureCropYield = 0.0;                  
//              futureVariableCosts = 0.0;      
//              futurePreHarvestCosts = 0.0;    
//      }
//
//      ///destructor
//      virtual ~PermanentCropsOfAgent()
//      {       currentLaborDemands.deallocate();
//              futureLaborDemands.deallocate();
//              currentMachineryDemands.deallocate();
//              futureMachineryDemands.deallocate();
//      }
//};
//*/

#endif

---