Farm.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2011, Christopher John Topping, Aarhus University
All rights reserved.
 
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
 
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
//
// Farm.h
//
/*
 
Copyright (c) 2003, National Environmental Research Institute, Denmark (NERI)
 
All rights reserved.
 
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 
*) Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
*) Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
*) Neither the name of the NERI nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
 
*/
 
#ifndef FARM_H
#define FARM_H
 
// This really needs to be a #define.
#define PROG_START 1
 
extern TTypesOfPopulation g_Species;
 
 
class Population_Manager;
class FarmManager;
class Farmer;
class BroadBeans;
class Carrots;
class CloverGrassGrazed1;
class CloverGrassGrazed2;
class FieldPeas;
class FieldPeasSilage;
class FodderBeet;
class FodderGrass;
class Maize;
class MaizeSilage;
class OMaizeSilage;
class OBarleyPeaCloverGrass;
class OCarrots;
class OCloverGrassGrazed1;
class OCloverGrassGrazed2;
class OCloverGrassSilage1;
class OFieldPeas;
class OFieldPeasSilage;
class OFirstYearDanger;
class OGrazingPigs;
class OOats;
class Oats;
class OrchardCrop;
class OFodderBeet;
class OPermanentGrassGrazed;
class OPotatoes;
class OSBarleySilage;
class OSeedGrass1;
class OSeedGrass2;
class OSpringBarley;
class OSpringBarleyExt;
class OSpringBarleyPigs;
class OWinterBarley;
class OWinterBarleyExt;
class OWinterRape;
class OWinterRye;
class OWinterWheatUndersown;
class OWinterWheatUndersownExt;
class PermanentGrassGrazed;
class PermanentGrassLowYield;
class PermanentGrassTussocky;
class PermanentSetAside;
class Potatoes;
class PotatoesIndustry;
class SeedGrass1;
class SeedGrass2;
class SetAside;
class SpringBarley;
class SpringBarleySpr;
class SpringBarleyPTreatment;
class SpringBarleySKManagement;
class SpringBarleyCloverGrass;
class SpringBarleySeed;
class SpringBarleySilage;
class SpringRape;
class SugarBeet;
class Triticale;
class OTriticale;
class WinterBarley;
class WinterRape;
class WinterRye;
class WinterWheat;
class WWheatPControl;
class WWheatPTreatment;
class WWheatPToxicControl;
class AgroChemIndustryCereal;
class WinterWheatStrigling;
class WinterWheatStriglingSingle;
class WinterWheatStriglingCulm;
class SpringBarleyCloverGrassStrigling;
class SpringBarleyStrigling;
class SpringBarleyStriglingCulm;
class SpringBarleyStriglingSingle;
class MaizeStrigling;
class WinterRapeStrigling;
class WinterRyeStrigling;
class WinterBarleyStrigling;
class FieldPeasStrigling;
class SpringBarleyPeaCloverGrassStrigling;
class YoungForestCrop;
class Hunter;
class OWinterWheat;
class NorwegianPotatoes;
class NorwegianOats;
class NorwegianSpringBarley;
 
class PLWinterWheat;
class PLWinterRape;
class PLWinterBarley;
class PLWinterTriticale;
class PLWinterRye;
class PLSpringWheat;
class PLSpringBarley;
class PLMaize;
class PLMaizeSilage;
class PLPotatoes;
class PLBeet;
class PLFodderLucerne1;
class PLFodderLucerne2;
class PLCarrots;
class PLSpringBarleySpr;
class PLWinterWheatLate;
class PLBeetSpr;
class PLBeans;
 
class PTOliveGroveTraditional;
class PTOliveGroveTradOrganic;
class PTOliveGroveIntensive;
class PTOliveGroveSuperIntensive;
 
class NLBeet;
class NLCarrots;
class NLMaize;
class NLPotatoes;
class NLSpringBarley;
class NLWinterWheat;
class NLCabbage;
class NLTulips;
class NLGrassGrazed1;
class NLGrassGrazed1Spring;
class NLGrassGrazed2;
class NLGrassGrazedLast;
class NLPermanentGrassGrazed;
class NLBeetSpring;
class NLCarrotsSpring;
class NLMaizeSpring;
class NLPotatoesSpring;
class NLSpringBarleySpring;
class NLCabbageSpring;
class NLCatchCropPea;
class NLOrchardCrop;
class NLPermanentGrassGrazedExtensive;
class NLGrassGrazedExtensive1;
class NLGrassGrazedExtensive1Spring;
class NLGrassGrazedExtensive2;
class NLGrassGrazedExtensiveLast;
class GenericCatchCrop;
 
class UKBeans;
class UKBeet;
class UKMaize;
class UKPermanentGrass;
class UKPotatoes;
class UKSpringBarley;
class UKTempGrass;
class UKWinterBarley;
class UKWinterRape;
class UKWinterWheat;
 
class PTPermanentGrassGrazed;
class PTWinterWheat;
class PTGrassGrazed;
class PTSorghum;
class PTFodderMix;
class PTTurnipGrazed;
class PTCloverGrassGrazed1;
class PTCloverGrassGrazed2;
class PTTriticale;
class PTOtherDryBeans;
class PTShrubPastures;
class PTCorkOak;
class PTVineyards;
class PTWinterBarley;
class PTBeans;
class PTWinterRye;
 
class DEOats;
class DESpringRye;
class DEWinterWheat;
class DEMazieSilage;
class DEPotatoes;
class DEMaize;
class DEWinterRye;
class DEWinterBarley;
class DEBeet;
class DEWinterRape;
class DETriticale;
class DECabbage;
class DECarrots;
class DEGrasslandSilageAnnual;
class DEGreenFallow_1year;
class DELegumes;
class DEOCabbages;
class DEOCarrots;
class DEOGrasslandSilageAnnual;
class DEOGreeFallow_1year;
class DEOLegumes;
class DEOMaize;
class DEOMaizeSilage;
class DEOOats;
class DEOPotatoes;
class DEOSpringRye;
class DEOTriticale;
class DEOWinterRye;
class DEOWinterRape;
class DEOWinterBarley;
class DEOWinterWheat;
class DEOSugarBeet;
class DEPermanentGrassGrazed;
class DEOPermanentGrassGrazed;
class DEPermanentGrassLowYield;
class DEWinterWheatlate;
class DEAsparagusEstablishedPlantation;
class DEHerbsPerennial_1year;
class DEHerbsPerennial_after1year;
class DESpringBarley;
class DEOrchard;
class DEPeas;
class DEOPeas;
class DEPotatoesIndustry;
class DEBushFruitPerm;
class DEOBushFruitPerm;
class DEOOrchard;
class DEOPermanentGrassLowYield;
class DEOAsparagusEstablishedPlantation;
class DEOHerbsPerennial_1year;
class DEOHerbsPerennial_after1year;
 
class DK_Cabbages;
class DK_Carrots;
class DK_Legume;
class DK_Legume_Whole;
class DK_OCabbages;
class DK_OCarrots;
class DK_OLegume;
class DK_OLegume_Whole;
class DK_OLegume_Whole;
class DK_OSugarBeets;
class DK_SugarBeets;
class DK_WinterWheat;
class DK_OWinterWheat;
class DK_CatchCrop;
class DK_SpringBarley;
class DK_OCatchCrop;
class DK_OSpringBarley;
class DK_OLegume_Beans;
class DK_OLegume_Peas;
class DK_OSpringOats;
class DK_OWinterWheat;
class DK_OWinterRye;
class DK_Legume_Beans;
class DK_Legume_Peas;
class DK_Legume_Whole;
class DK_SpringOats;
class DK_WinterWheat;
class DK_WinterRye;
class DK_GrassTussocky_Perm;
 
class DummyCropPestTesting;
 
enum class CatchCropTypes : unsigned
{
    cctGenericCatchCrop = 0
};
 
typedef vector<unsigned >polylist;
typedef vector < Hunter* > HunterList;
 
struct FarmerAttributes {
    double envA; 
    double riskA;
    int Cooperative;
    int Age;
    double riskSpan;
};
 
struct FarmFuncsCostBenefits {
    double LabourCost;
    double EconomicCost;
    double RiskAvoidance;
    double EnvImpact;
    FarmManagementCategory ManagementCategory;
};
 
struct pesticiderecord {
    double m_amounts[ppp_foobar];
    bool m_present;
};
 
struct PermCropData {
    TTypesOfVegetation Tov;
    int Pct;
};
 
struct tpct {
    int index;
    int pct;
};
 
struct FarmEvent
{
    bool       m_lock;
    int        m_startday;
    bool       m_first_year;
    long       m_run;
    int        m_todo;
    TTypesOfVegetation m_event;
    TTypesOfVegetation m_next_tov;
    LE* m_field;
    bool        m_forcespring;
    bool        m_forcespringOK;
 
    FarmEvent(TTypesOfVegetation a_event, LE* a_field, int a_todo, long a_run, bool a_lock, int a_start, bool a_first_year, TTypesOfVegetation a_nextcrop, bool a_forcespring, bool a_forcespringOK)
    {
        m_event = a_event;
        m_field = a_field;
        m_todo = a_todo;
        m_run = a_run;
        m_lock = a_lock;
        m_startday = a_start;
        m_first_year = a_first_year;
        m_next_tov = a_nextcrop;
        m_forcespring = a_forcespring;
        m_forcespringOK = a_forcespringOK;
    }
};
 
struct farminfo {
    int m_farmref;
    int m_farmtype;
    int m_farmsize;
    int m_farmarable;
    int m_nofields;
    int m_openfields;
    int m_areaopenfields;
    APoint m_farmcentroid;
    APoint m_farmvalid;
    int m_NoHunters;
};
 
struct CropStartStruct
{
    int m_stMonth;
    int m_stDay;
};
class HunterInfo
{
public:
    int refID;
    int homeX;
    int homeY;
    vector<int> FarmHuntRef;
    vector<int> CheckedFarms;
 
    ~HunterInfo() {
        FarmHuntRef.resize( 0 );
        CheckedFarms.resize( 0 );
    }
};
 
class FarmerList
{
protected:
    vector<Farmer*> m_TheFarmers;
public:
    FarmerList()
    {
        m_TheFarmers.resize(0);
    }
    void AddFarmer(Farmer* a_farmer) { m_TheFarmers.push_back(a_farmer); }
    Farmer* GetFarmer(int i) { return m_TheFarmers[i]; }
    void ReplaceFarmer(int i, Farmer* a_farmer) { m_TheFarmers[i] = a_farmer; }
    int GetSize() { return int(m_TheFarmers.size()); }
    APoint GetLocation(int i);
    void UpdateSocialNetworks(bool a_geographic, bool a_associative, bool a_virtual);
    void ResetAllDone();
    // /** \brief Prints the social attributes of all farmers to a file */
 
};
 
class Crop
{
protected:
  Farm      *m_farm;
  LE        *m_field;
  FarmEvent *m_ev;
  int        m_first_date;
  int        m_count;
  int        m_last_date;
  int        m_ddegstoharvest;
  int        m_base_elements_no;
  Landscape *m_OurLandscape;
  bool      m_forcespringpossible = false;
  TTypesOfCrops m_toc;
  int       m_CropClassification;
  static int m_date_modifier;
  void SimpleEvent(long a_date, int a_todo, bool a_lock);
 
  void SimpleEvent_(long a_date, int a_todo, bool a_lock, Farm* a_farm, LE* a_field);
  vector<FarmManagementCategory> m_ManagementCategories;
  bool StartUpCrop(int a_spring, std::vector<std::vector<int>> a_flexdates, int a_todo);
 
  bool AphidDamage(LE* a_field);
 
public:
    TTypesOfVegetation m_tov;
    virtual ~Crop() {}
    Crop(TTypesOfVegetation a_tov, TTypesOfCrops a_toc, Landscape* a_L);
    int GetFirstDate( void ) { return m_first_date; }
    virtual bool Do( Farm *a_farm,  LE *a_field, FarmEvent *a_ev );
    void ChooseNextCrop (int a_no_dates);
    //* \brief Get method for m_CropClassification */
    int GetCropClassification() { return m_CropClassification; }
    //* \brief Get method for m_CropClassification */
    void SetCropClassification(int a_classification) { m_CropClassification = a_classification; }
    //* \brief Sets the crop type */
    void GetCropType(TTypesOfCrops a_toc) { m_toc = a_toc; }
    //* \brief Gets the crop type */
    TTypesOfCrops GetCropType() { return m_toc; }
    //* \brief Get the translation between farm operation and management category */
    FarmManagementCategory LookUpManagementCategory(int a_todo) {
        return m_ManagementCategories[a_todo];
    }
    bool GetForceSpringOK() { return m_forcespringpossible; }
};
 
 
// v. similar to PermCropData, but has double instead of int. 
//Used originally for saving Bedriftsmodel (original farm optimization model) type crops in almass type. Also used to store data on biomass_factors
//so changed the name of the member - from Pct to Number
 
    struct AlmassCrop {
        double Number;
        TTypesOfVegetation Tov;
    };
 
class DataForOptimisation {
 
public:
    DataForOptimisation();
 
    //Data at a general level
    void Set_livestockTypes(TTypesOfFarmAnimals livestock_type){m_livestockTypes.push_back(livestock_type);};
    void Set_cropTypes(TTypesOfCrops crop_type){m_cropTypes.push_back(crop_type);};
    void Set_cropTypes_str (string crop_type){m_str_cropTypes.push_back(crop_type);};
    TTypesOfFarmAnimals Get_livestockTypes(int i){return m_livestockTypes[i];};
    string Get_cropTypes_str (int i) {return m_str_cropTypes[i];};
    TTypesOfCrops Get_cropTypes(int i) {return m_cropTypes[i];};
 
    //Individual data for farms (vector size is no_farms x given_Foobar)
    void Set_livestockNumber(int a_number){m_livestockNumbers.push_back(a_number);}; 
    void Set_cropArea(double a_area){m_cropAreas.push_back(a_area);};
    int Get_livestockNumber(int index){return m_livestockNumbers[index];}; 
    int Get_livestockNumbersSize(){return (int)m_livestockNumbers.size();};
    double Get_cropArea(int index){return m_cropAreas[index];};
    int Get_cropAreasSize(){return (int)m_cropAreas.size();};
 
    //Data for farms
    TTypesOfOptFarms Get_farmType (int a_almass_no);
    void Set_winterMax (int a_value, int i){m_winterMax[i]=a_value;};
    int Get_winterMax (int i) {return m_winterMax[i];};
 
    //Data for livestock
    void Set_livestockParameter(double a_value, int i){m_livestockParameters[i]=a_value;};
    double Get_livestockParameter(int i){return m_livestockParameters[i];};
 
    //Data for crops
    void Set_cropParameter (double a_value, int i){m_cropParameters[i]=a_value;};
    double Get_cropParameter (int i) {return m_cropParameters[i];};
 
    void Set_alfa (double a_value, int i){m_alfa[i]=a_value;};
    double Get_alfa (int i) {return m_alfa[i];};
    void Set_beta1 (double a_value, int i){m_beta1[i]=a_value;};
    double Get_beta1 (int i) {return m_beta1[i];};
    void Set_beta2 (double a_value, int i){m_beta2[i]=a_value;};
    double Get_beta2 (int i) {return m_beta2[i];};
    void Set_Nnorm (double a_value, int i){m_Nnorm[i]=a_value;};
    double Get_Nnorm (int i) {return m_Nnorm[i];};
 
 
    void Set_fixed (string a_value, int i){
        if(a_value=="yes" || a_value=="YES" || a_value=="Yes" || a_value=="1"){m_fixed[i]=true;}
        else {m_fixed[i]=false;}
    };
    bool Get_fixed (int i) {return m_fixed[i];};
    void Set_fodder (string a_value, int i){
        if(a_value=="yes" || a_value=="YES" || a_value=="Yes" || a_value=="1"){m_fodder[i]=true;}
        else {m_fodder[i]=false;}
    };
    bool Get_fodder (int i) {return m_fodder[i];};
    void Set_FUKey (double a_value, int i){m_FUKey[i]=a_value;};
    double Get_FUKey (int i) {return m_FUKey[i];};
 
    void Set_sellingPrice (double a_value, int i){m_sellingPrice[i]=a_value;};
    double Get_sellingPrice (int i) {return m_sellingPrice[i];};
    void Set_sellingPrice_lastyr (double a_value, int i){m_sellingPrice_lastyr[i]=a_value;};
    double Get_sellingPrice_lastyr (int i) {return m_sellingPrice_lastyr[i];};
 
    void Set_rotationMax (double a_value, int i){m_rotationMax[i]=a_value;};
    double Get_rotationMax (int i) {return m_rotationMax[i];};
    void Set_rotationMin (double a_value, int i){m_rotationMin[i]=a_value;};
    double Get_rotationMin (int i) {return m_rotationMin[i];};
 
 
    //versions for almass crops
    void Set_biomass_factor (double a_value, int i){m_biomass_factors[i] = a_value;};
    double Get_biomass_factor (int i) { return m_biomass_factors[i];} 
 
    void Set_cropTypes_almass(TTypesOfVegetation crop_type){m_cropTypes_almass.push_back(crop_type);};
    TTypesOfVegetation Get_cropTypes_almass (int i) {return m_cropTypes_almass[i];};
    int Get_cropTypes_almass_size (){return (int)m_cropTypes_almass.size();};
    void Set_cropTypes_almass_str (string crop_type){m_str_cropTypes_almass.push_back(crop_type);};
    string Get_cropTypes_almass_str (int i) {return m_str_cropTypes_almass[i];};
 
    void Set_noCrops (int no) {m_noCrops = no;};
    int Get_noCrops (){return m_noCrops;};
 
    void Set_emaize_price (double a_value){m_energy_maize_price.push_back(a_value);};
    double Get_emaize_price (int i){return m_energy_maize_price[i];};
 
    class FarmData{
    public:
        int md_almass_no;
        TTypesOfOptFarms md_farmType;
        TTypesOfSoils md_soilType;
        TTypesOfFarmSize md_farmSize;
        int md_farmRealID;
        int md_soilSubType;
    };
 
    vector<FarmData*>m_farm_data;
 
 
protected:
 //called in the constructor
    void InitializeVector(vector<double>&vector);
    int m_noCrops; //how many crops will be optimised - the number is taken from one of the input files; it has to be the same in all input files with crop data!
 
//I. Data at a general level - changed to config variables
 
//II. Data for farms
 
    vector<string>m_str_cropTypes; //used in output function
    vector<TTypesOfCrops>m_cropTypes;
    //for almass crop types
    vector<string>m_str_cropTypes_almass;
    vector<TTypesOfVegetation>m_cropTypes_almass;
    vector<TTypesOfFarmAnimals>m_livestockTypes;
    vector<double>m_cropAreas;
    vector<int>m_livestockNumbers;
 
    vector<int>m_winterMax;
 
//III. Data for livestock
    vector<double>m_livestockParameters; //full list of the parameters - enum declaration (TTypesOfLivestockParameters)
 
//IV. Data for crops
    //1. parameters that do not vary with farm type, soil type etc. (number of parameters = top_Foobar !)
        vector<double>m_cropParameters; //full list of the parameters - enum declaration (enum TTypesOfParameters)
    //2. parameters that vary with a soil type
        vector<double>m_alfa;
        vector<double>m_beta1;
        vector<double>m_beta2;
        vector<double>m_Nnorm;
        vector<double>m_biomass_factors;
 
    //3. parameters that vary with a farm type
        vector<bool>m_fixed;
        vector<bool>m_fodder;
        vector<double>m_FUKey;
    //4. parameters that vary with a farm and soil type
        vector<double>m_sellingPrice;
        vector<double>m_sellingPrice_lastyr;
    //5. parameters that vary with a farm type, farm size and a soil type
        vector<double>m_rotationMax;
        vector<double>m_rotationMin;
 
    //6. Energy maize runs
        vector<double>m_energy_maize_price;
 
};
 
class Farm
{
public:
 
    string m_rotfilename;
 
    virtual void FarmActions(void);
    bool FarmerActions(void);
 
    // InitiateManagement() must be called after all the fields have
    // been added to the farm.
    virtual void InitiateManagement(void);
 
    void     AddField(LE* a_newfield);
    void     RemoveField(LE* a_field);
    Farm(FarmManager* a_manager);
    virtual ~Farm(void);
    void SetFarmNumber(int a_farm_num) { m_farm_num = a_farm_num; }
    int  GetFarmNumber(void) { return m_farm_num; }
    virtual bool Spraying_herbicides(TTypesOfVegetation) { return true; };
    virtual bool Spraying_fungins(TTypesOfVegetation) { return true; };
    virtual double Prob_multiplier() { return 1; };
    void Assign_rotation(vector<TTypesOfVegetation>a_new_rotation);
    FarmManager* GetFarmManager() { return m_OurManager; }
 
    /************************* Economics **********************************/
    virtual void Harvested(TTypesOfCrops a_toc, double a_yield);
    virtual void Insecticide(int a_area);
    virtual void Herbicide(int a_area);
    /*********************** End Economics ********************************/
    TTypesOfFarm GetFarmType() { return m_FarmType; }
    polylist* ListOpenFields(int a_openness); //14.01.13
    void Centroids();
    int GetNoFields() { return (int)m_fields.size(); }
    int GetNoOpenFields(int a_openness);
    int GetAreaOpenFields(int a_openness);
    APoint GetValidCoords() { APoint pt;  pt.m_x = m_fields[0]->GetValidX(); pt.m_y = m_fields[0]->GetValidY(); return pt; }
    int GetMaxOpenness()
    {
        int op = 0;
        for (int i = 0; i < m_fields.size(); i++)
        {
            int openness = m_fields[i]->GetOpenness();
            if (openness > op) op = openness;
        }
        return op;
    }
 
    Farmer* GetFarmer() { return m_OurFarmer; }
 
    // And (*sigh*) the crop treatment functions... :-)
    LE* SetFunctionData(LE*, double, double, int, FarmToDo);
    void SetFunctionDataNoUM(LE*, double, double, int, FarmToDo);
    virtual bool SleepAllDay(LE* a_field, double a_user, int a_days);
    virtual bool AutumnPlough(LE* a_field, double a_user, int a_days);
    void CalculateTreatmentCosts(FarmToDo a_treatment, LE* a_field);
    virtual bool StubblePlough(LE* a_field, double a_user, int a_days);
    virtual bool StubbleCultivatorHeavy(LE* a_field, double a_user, int a_days);
    virtual bool AutumnHarrow(LE* a_field, double a_user, int a_days);
    virtual bool AutumnRoll(LE* a_field, double a_user, int a_days);
    virtual bool PreseedingCultivator(LE* a_field, double a_user, int a_days);
    virtual bool PreseedingCultivatorSow(LE* a_field, double a_user, int a_days, double a_seed_coating_amount = -1, PlantProtectionProducts a_ppp = ppp_foobar);
    virtual bool AutumnSow(LE* a_field, double a_user, int a_days, double a_seed_coating_amount = -1, PlantProtectionProducts a_ppp = ppp_foobar);
    virtual bool WinterPlough(LE* a_field, double a_user, int a_days);
    virtual bool WinterHarrow(LE* a_field, double a_user, int a_days);
    virtual bool DeepPlough(LE* a_field, double a_user, int a_days);
    virtual bool SpringPlough(LE* a_field, double a_user, int a_days);
    virtual bool SpringHarrow(LE* a_field, double a_user, int a_days);
    virtual bool SpringRoll(LE* a_field, double a_user, int a_days);
    virtual bool SpringSow(LE* a_field, double a_user, int a_days, double a_seed_coating_amount = -1, PlantProtectionProducts a_ppp = ppp_foobar);
    virtual bool SpringSowWithFerti(LE* a_field, double a_user, int a_days, double a_seed_coating_amount = -1, PlantProtectionProducts a_ppp = ppp_foobar);
    virtual bool AutumnSowWithFerti(LE* a_field, double a_user, int a_days, double a_seed_coating_amount = -1, PlantProtectionProducts a_ppp = ppp_foobar);
    virtual bool HerbicideTreat(LE* a_field, double a_user, int a_days);
    virtual bool GrowthRegulator(LE* a_field, double a_user, int a_days);
    virtual bool FungicideTreat(LE* a_field, double a_user, int a_days);
    virtual bool InsecticideTreat(LE* a_field, double a_user, int a_days);
    virtual bool BiocideTreat(LE* a_field, double a_user, int a_days);
    virtual bool OrganicInsecticide(LE* a_field, double a_user, int a_days);
    virtual bool OrganicHerbicide(LE* a_field, double a_user, int a_days);
    virtual bool OrganicFungicide(LE* a_field, double a_user, int a_days);
    virtual bool Pheromone(LE* a_field, double a_user, int a_days);
    virtual bool ProductApplication(LE* a_field, double a_user, int a_days, double a_applicationrate, PlantProtectionProducts a_ppp, bool a_isgranularpesticide = false, int a_orcharddrifttype = 0);
    virtual bool ProductApplication_DateLimited(LE* a_field, double, int, double a_applicationrate, PlantProtectionProducts a_ppp, bool a_isgranularpesticide = false);
    virtual bool Molluscicide(LE* a_field, double a_user, int a_days);
    virtual bool RowCultivation(LE* a_field, double a_user, int a_days);
    virtual bool Strigling(LE* a_field, double a_user, int a_days);
    virtual bool StriglingSow(LE* a_field, double a_user, int a_days, double a_seed_coating_amount = -1, PlantProtectionProducts a_ppp = ppp_foobar);
    virtual bool StriglingHill(LE* a_field, double a_user, int a_days);
    virtual bool HillingUp(LE* a_field, double a_user, int a_days);
    virtual bool Water(LE* a_field, double a_user, int a_days);
    virtual bool Swathing(LE* a_field, double a_user, int a_days);
    virtual bool Harvest(LE* a_field, double a_user, int a_days);
    virtual bool HarvestLong(LE* a_field, double a_user, int a_days);
    virtual bool HarvestBushFruit(LE* a_field, double a_user, int a_days);
    virtual bool HarvestBF_Machine(LE* a_field, double a_user, int a_days);
    virtual bool CattleOut(LE* a_field, double a_user, int a_days);
    virtual bool CattleOut(LE* a_field, double a_user, int a_days, bool a_should_eat);
    virtual bool CattleOutLowGrazing(LE* a_field, double a_user, int a_days);
    virtual bool CattleIsOut(LE* a_field, double a_user, int a_days, int a_max);
    virtual bool CattleIsOut(LE* a_field, double a_user, int a_days, int a_max, bool a_should_eat);
    virtual bool CattleIsOutLow(LE* a_field, double a_user, int a_days, int a_max);
    virtual bool CattleIsOutLow2(LE* a_field, double a_user, int a_days, int a_max, int a_max_days);
    virtual bool PigsOut(LE* a_field, double a_user, int a_days);
    virtual bool PigsAreOut(LE* a_field, double a_user, int a_days);
    virtual bool PigsAreOutForced(LE* a_field, double a_user, int a_days);
    virtual bool CutToHay(LE* a_field, double a_user, int a_days);
    virtual bool CutWeeds(LE* a_field, double a_user, int a_days);
    virtual bool CutToSilage(LE* a_field, double a_user, int a_days);
    virtual bool CutOrch(LE* a_field, double a_user, int a_days); //added 27.08.12
    virtual bool StrawChopping(LE* a_field, double a_user, int a_days);
    virtual bool HayTurning(LE* a_field, double a_user, int a_days);
    virtual bool HayBailing(LE* a_field, double a_user, int a_days);
    virtual bool BurnStrawStubble(LE* a_field, double a_user, int a_days);
    virtual bool BurnTop(LE* a_field, double a_user, int a_days);
    virtual bool StubbleHarrowing(LE* a_field, double a_user, int a_days);
    virtual bool FP_NPKS(LE* a_field, double a_user, int a_days);
    virtual bool FP_NPK(LE* a_field, double a_user, int a_days);
    virtual bool FP_NC(LE* a_field, double a_user, int a_days);
    virtual bool FP_NK(LE* a_field, double a_user, int a_days);
    virtual bool FP_NS(LE* a_field, double a_user, int a_days);
    virtual bool FP_N(LE* a_field, double a_user, int a_days);
    virtual bool FP_PK(LE* a_field, double a_user, int a_days);
    virtual bool FP_P(LE* a_field, double a_user, int a_days);
    virtual bool FP_K(LE* a_field, double a_user, int a_days);
    virtual bool FP_SK(LE* a_field, double a_user, int a_days);
    virtual bool FP_LiquidNH3(LE* a_field, double a_user, int a_days);
    virtual bool FP_Slurry(LE* a_field, double a_user, int a_days);
    virtual bool FP_ManganeseSulphate(LE* a_field, double a_user, int a_days);
    virtual bool FP_Boron(LE* a_field, double a_user, int a_days);
    virtual bool FP_AmmoniumSulphate(LE* a_field, double a_user, int a_days);
    virtual bool FP_Manure(LE* a_field, double a_user, int a_days);
    virtual bool FP_GreenManure(LE* a_field, double a_user, int a_days);
    virtual bool FP_Sludge(LE* a_field, double a_user, int a_days);
    virtual bool FP_RSM(LE* a_field, double a_user, int a_days);
    virtual bool FP_Calcium(LE* a_field, double a_user, int a_days);
    virtual bool FA_NK(LE* a_field, double a_user, int a_days);
    virtual bool FA_NPKS(LE* a_field, double a_user, int a_days);
    virtual bool FA_NPK(LE* a_field, double a_user, int a_days);
    virtual bool FA_PK(LE* a_field, double a_user, int a_days);
    virtual bool FA_P(LE* a_field, double a_user, int a_days);
    virtual bool FA_K(LE* a_field, double a_user, int a_days);
    virtual bool FA_SK(LE* a_field, double a_user, int a_days);
    virtual bool FA_Slurry(LE* a_field, double a_user, int a_days);
    virtual bool FA_ManganeseSulphate(LE* a_field, double a_user, int a_days);
    virtual bool FA_AmmoniumSulphate(LE* a_field, double a_user, int a_days);
    virtual bool FA_Manure(LE* a_field, double a_user, int a_days);
    virtual bool FA_GreenManure(LE* a_field, double a_user, int a_days);
    virtual bool FA_Sludge(LE* a_field, double a_user, int a_days);
    virtual bool FA_RSM(LE* a_field, double a_user, int a_days);
    virtual bool FA_Calcium(LE* a_field, double a_user, int a_days);
    virtual bool BedForming(LE* a_field, double a_user, int a_days);
    virtual bool ShallowHarrow(LE* a_field, double a_user, int a_days);
    virtual bool HeavyCultivatorAggregate(LE* a_field, double a_user, int a_days);
    virtual bool FlowerCutting(LE* a_field, double a_user, int a_days);
    virtual bool BulbHarvest(LE* a_field, double a_user, int a_days);
    virtual bool StrawCovering(LE* a_field, double a_user, int a_days);
    virtual bool StrawRemoval(LE* a_field, double a_user, int a_days);
    virtual bool IrrigationStart(LE* a_field, double a_user, int a_days);
    virtual bool Irrigation(LE* a_field, double a_user, int a_days, int a_max);
    virtual bool Pruning(LE* a_field, double a_user, int a_days);
    virtual bool Shredding(LE* a_field, double a_user, int a_days);
    virtual bool LeafThinning(LE* a_field, double a_user, int a_days);
    virtual bool GreenHarvest(LE* a_field, double a_user, int a_days);
    virtual bool FruitHarvest(LE* a_field, double a_user, int a_days);
    virtual bool Suckering(LE* a_field, double a_user, int a_days);
    virtual bool Mowing(LE* a_field, double a_user, int a_days);
    virtual bool FiberCovering(LE* a_field, double a_user, int a_days);
    virtual bool FiberRemoval(LE* a_field, double a_user, int a_days);
    virtual bool FP_Cu(LE* a_field, double a_user, int a_days);
    virtual bool FA_N(LE* a_field, double a_user, int a_days);
    virtual bool FA_Cu(LE* a_field, double a_user, int a_days);
    virtual bool FA_Boron(LE* a_field, double a_user, int a_days);
    virtual bool FA_PKS(LE* a_field, double a_user, int a_days);
    virtual bool FP_PKS(LE* a_field, double a_user, int a_days);
    virtual bool HarvestShoots(LE* a_field, double a_user, int a_days);
    virtual bool ManualWeeding(LE* a_field, double a_user, int a_days);
 
    // User functions for the treatment steps:
    void AddNewEvent(TTypesOfVegetation a_event, long a_date,
        LE* a_field, int a_todo, long a_num,
        bool a_lock, int a_start,
        bool a_first_year, TTypesOfVegetation a_crop, FarmManagementCategory a_fmc,
        bool a_forcespring, bool a_forcespringOK);
    bool DoIt(double a_probability);
    bool DoIt_prob(double a_probability);
    TTypesOfFarm  GetType(void) { return m_farmtype; }
    string GetRotFilename(void) { return m_rotfilename; }
    int GetArea(void);
    int GetTotalArea(void);
    double GetAreaDouble(void);
    bool IsStockFarmer(void) { return m_stockfarmer; }
    virtual void MakeStockFarmer(void) { m_stockfarmer = true; }
    double GetIntensity(void) { return m_intensity; }
    void SetIntensity(double a_intensity) { m_intensity = a_intensity; }
    APoint GetCentroids() { APoint pt; pt.m_x = m_farm_centroidx; pt.m_y = m_farm_centroidy; return pt; }
    TTypesOfVegetation GetPreviousTov(int a_index) {
        int ind = a_index - 1;
        if (ind < 0) ind = (int)m_rotation.size() - 1;
        return m_rotation[ind];
    }
    TTypesOfVegetation GetCrop(int a_index) {
        return m_rotation[a_index];
    }
    TTypesOfVegetation GetNextCrop(int a_index) {
        int ind = a_index + 1;
        if (ind >= (int)m_rotation.size()) ind = ind - (int)m_rotation.size();
        return m_rotation[ind];
    }
    int GetNoCrops() {
        return (int)m_rotation.size();
    }
    void AddHunter(Hunter* a_hunter) {
        m_HuntersList.push_back(a_hunter);
    }
    void RemoveHunter(Hunter* a_hunter) {
        for (int h = 0; h < m_HuntersList.size(); h++) {
            if (m_HuntersList[h] == a_hunter) {
                m_HuntersList.erase(m_HuntersList.begin() + h);
            }
        }
    }
 
    int GetNextCropStartDate(LE* a_field, TTypesOfVegetation& a_curr_veg);
 
protected:
    FarmManager* m_OurManager;
    Farmer* m_OurFarmer;
    LowPriority< FarmEvent* >  m_queue;
    vector< LE* >              m_fields;
    vector<TTypesOfVegetation> m_rotation;
    vector<PermCropData>        m_PermCrops;
    TTypesOfFarm  m_farmtype;
    HunterList m_HuntersList;
    bool m_stockfarmer;
    int m_farm_num;
    int m_rotation_sync_index;
    double m_intensity;
    int GetFirstDate(TTypesOfVegetation a_tov);
    int GetForceSpringOK(TTypesOfVegetation a_tov);
    virtual int GetFirstCropIndex(TTypesOfLandscapeElement a_type);
    virtual int GetNextCropIndex(int a_rot_index);
    virtual void HandleEvents(void);
    bool LeSwitch(FarmEvent* ev);
    void CheckRotationManagementLoop(FarmEvent* ev);
    void ReadRotation(std::string fname);
 
    void AssignPermanentCrop(TTypesOfVegetation tov, int pct); //MOVED FROM THE  USER DEFINED FARM
    int InvIntPartition(vector<tpct>* items, int target);
    int m_farm_centroidx;
    int m_farm_centroidy;
    TTypesOfFarm m_FarmType; // default is tof_foobar
 
};
 
 
class ConventionalCattle : public Farm
{
public:
  ConventionalCattle( FarmManager* a_manager );
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class ConventionalPig : public Farm
{
public:
    ConventionalPig(FarmManager* a_manager);
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class ConventionalPlant : public Farm
{
public:
    ConventionalPlant(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class OrganicPlant : public Farm
{
public:
    OrganicPlant(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class OrganicPig : public Farm
{
public:
    OrganicPig(FarmManager* a_manager);
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class OrganicCattle : public Farm
{
public:
    OrganicCattle(FarmManager* a_manager);
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class PesticideTrialControl : public Farm
{
public:
    PesticideTrialControl(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
};
 
class PesticideTrialToxicControl : public Farm
{
public:
    PesticideTrialToxicControl(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
};
 
class PesticideTrialTreatment : public Farm
{
public:
    PesticideTrialTreatment(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
};
 
 
 
class ConvMarginalJord : public Farm
{
public:
    ConvMarginalJord(FarmManager* a_manager);
};
 
 
class AgroChemIndustryCerealFarm1 : public Farm
{
public:
    AgroChemIndustryCerealFarm1(FarmManager* a_manager);
};
 
class AgroChemIndustryCerealFarm2 : public Farm
{
public:
    AgroChemIndustryCerealFarm2(FarmManager* a_manager);
};
 
class AgroChemIndustryCerealFarm3 : public Farm
{
public:
    AgroChemIndustryCerealFarm3(FarmManager* a_manager);
};
 
class NoPesticideBaseFarm : public Farm
{
public:
    NoPesticideBaseFarm(FarmManager* a_manager);
};
 
class NoPesticideNoPFarm : public Farm
{
public:
    NoPesticideNoPFarm(FarmManager* a_manager);
};
 
class UserDefinedFarm : public Farm
{
public:
    UserDefinedFarm(TTypesOfFarm farm_type, const char* fname, FarmManager* a_manager);
protected:
    virtual void InitiateManagement( void );
    //void AssignPermanentCrop(TTypesOfVegetation tov, int pct); //MOVED TO THE FARM CLASS
    //int InvIntPartition(vector<tpct>* items, int target);
    //void TranslateBitsToFields(int bits, vector<LE*> &f_cpy, TTypesOfVegetation tov);
};
 
class UserDefinedFarm1 : public Farm
{
public:
    UserDefinedFarm1(FarmManager* a_manager);
};
 
class UserDefinedFarm2 : public Farm
{
public:
    UserDefinedFarm2(FarmManager* a_manager);
};
 
class UserDefinedFarm3 : public Farm
{
public:
    UserDefinedFarm3(FarmManager* a_manager);
};
 
class UserDefinedFarm4 : public Farm
{
public:
    UserDefinedFarm4(FarmManager* a_manager);
};
 
class UserDefinedFarm5 : public Farm
{
public:
    UserDefinedFarm5(FarmManager* a_manager);
};
 
class UserDefinedFarm6 : public Farm
{
public:
    UserDefinedFarm6(FarmManager* a_manager);
};
 
class UserDefinedFarm7 : public Farm
{
public:
    UserDefinedFarm7(FarmManager* a_manager);
};
 
class UserDefinedFarm8 : public Farm
{
public:
    UserDefinedFarm8(FarmManager* a_manager);
};
 
class UserDefinedFarm9 : public Farm
{
public:
    UserDefinedFarm9(FarmManager* a_manager);
};
 
class UserDefinedFarm10 : public Farm
{
public:
    UserDefinedFarm10(FarmManager* a_manager);
};
 
class UserDefinedFarm11 : public Farm
{
public:
    UserDefinedFarm11(FarmManager* a_manager);
};
 
class UserDefinedFarm12 : public Farm
{
public:
    UserDefinedFarm12(FarmManager* a_manager);
};
 
class UserDefinedFarm13 : public Farm
{
public:
    UserDefinedFarm13(FarmManager* a_manager);
};
 
class UserDefinedFarm14 : public Farm
{
public:
    UserDefinedFarm14(FarmManager* a_manager);
};
 
class UserDefinedFarm15 : public Farm
{
public:
    UserDefinedFarm15(FarmManager* a_manager);
};
 
class UserDefinedFarm16 : public Farm
{
public:
    UserDefinedFarm16(FarmManager* a_manager);
};
 
class UserDefinedFarm17 : public Farm
{
public:
    UserDefinedFarm17(FarmManager* a_manager);
};
 
//--------------------------------------------------------------------------------------------
//--------------------------OptimisingFarm----------------------------------------------------
//--------------------------------------------------------------------------------------------
 
class Livestock {
    public:
        Livestock(TTypesOfFarmAnimals a_animalType, int a_number);
        TTypesOfFarmAnimals m_animalType;
        int m_number;
        double m_NanimUsable;
        double m_FUdemand;
    };
 
class CropOptimised {
    public:
        CropOptimised(TTypesOfCrops a_cropType, double a_initialArea);
        CropOptimised(TTypesOfVegetation a_cropType, double a_initialArea); 
        CropOptimised(); //another constructor - for the fake crop
 
        double m_initialArea;
        TTypesOfCrops m_cropType;
        TTypesOfVegetation m_cropType_almass;
 
    //parameters: here saved - to make it easier to read them (they are needed very often)
        double m_rotationMax;
        double m_rotationMin;
 
    //optimised variables
        double m_n;
        double m_nt;
        double m_optimalN;
 
        double m_benefit;
        double m_resp;
        double m_BIHerb;
        double m_BIFi;
        double m_BI;
        double m_grooming;
        double m_hoeing; 
        double m_weeding;
        double m_lossHerb;
        double m_lossFi;
        double m_totalLoss;
        double m_costs_ha;
        double m_income_ha;
        double m_GM;
        double m_savings; 
        double m_GM_Savings;
        double m_areaPercent;
        double m_areaVariable;
        double m_area_ha;
};
 
class FarmManager
{
public:
    FarmManager(Landscape * landscape);
    ~FarmManager();
    void FarmManagement();
    void InitiateManagement(void);
    void UpdateSocialNetworks(bool a_geographic, bool a_associative, bool a_virtual);
    Landscape* GetLandscape(void) { return m_landscape; }
    void AddField(int a_OwnerIndex, LE* a_newland, int a_Owner);
    void RemoveField(int a_OwnerIndex, LE* a_field);
    int ConnectFarm(int a_owner);
 
    TTypesOfVegetation TranslateVegCodes(std::string& str); //moved from farm
    TTypesOfCrops TranslateCropCodes(string& str);
    std::string BackTranslateCropCodes(TTypesOfCrops a_crop);
    void ReadCropYieldReturns();
    void ReadCropManagementNorms();
    void ReadFarmerAttributes();
    void ReadFarmFunctionsCB();
    void PrintLocationAndArea();
    void DumpFarmAreas();
    void DumpFarmrefs(const char* a_filename);
    int GetFarmTotalSize(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetTotalArea());
    }
    int GetFarmArableSize(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetArea());
    }
    TTypesOfFarm GetFarmType(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetType());
    }
    int GetFarmNoFields(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetNoFields());
    }
    APoint GetFarmValidCoords(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetValidCoords());
    }
    
    int GetFarmNoOpenFields(int a_farmref, int a_openness)
    {
        return (GetFarmPtr(a_farmref)->GetNoOpenFields(a_openness));
    }
 
    int GetFarmAreaOpenFields(int a_farmref, int a_openness)
    {
        return (GetFarmPtr(a_farmref)->GetAreaOpenFields(a_openness));
    }
 
    Farm* GetFarmPtr( int a_owner ) {
        for (unsigned int i = 0; i < m_farms.size( ); i++) {
            if (a_owner == m_farms[ i ]->GetFarmNumber( )) {
                return m_farms[ i ];
            }
        }
        g_msg->Warn( "FarmManager::GetFarmPtr - missing farm ref", a_owner );
        exit( 92 );
    }
    
    double GetManagementNorm(int a_crop, int a_managementtype) {    return m_MangagementNorms[a_crop][a_managementtype]; }
 
    Farm* GetFarmPtrIndex( int a_index) {
                return m_farms[ a_index ];
    }
    int GetRandomFarmRefnum() { return m_farms[g_random_fnc((int)m_farms.size())]->GetFarmNumber(); }
    void CalcCentroids() { for (unsigned int i = 0; i < m_farms.size(); i++) m_farms[i]->Centroids(); }
    bool InIllegalList( int a_farm_ref, vector<int> * a_farmlist );
    void AddToIllegalList( int a_farm_ref, vector<int> * a_farmlist );
    int FindClosestFarm(HunterInfo a_hinfo, vector<int> *a_farmlist);
    //int FindClosestFarmProb(HunterInfo a_hinfo, vector<int> *a_farmlist);
    int FindClosestFarmOpenness( HunterInfo a_hinfo, vector<int> * a_farmlist, int a_openness );
    int FindClosestFarmOpennessProb( HunterInfo a_hinfo, vector<int> * a_farmlist, int a_openness );
    int FindClosestFarmOpennessProbSmallIsBest( HunterInfo a_hinfo, vector<int> * a_farmlist, int a_openness, vector<int> * a_farmsizelist );
    int FindClosestFarmOpennessProbNearRoostIsBest( HunterInfo a_hinfo, vector<int> * a_farmlist, int a_openness, vector<APoint> * a_farmsizelist );
    int FindFarmWithRandom(vector<int> * a_farmlist);
    int FindFarmWithOpenness(vector<int> * a_farmlist, int a_openness);
    int FindOpennessFarm(int a_openness);
    bool CheckOpenness( int a_openness, int a_ref );
    APoint GetFarmCentroid(int a_farmref)
    {
        for (unsigned int i = 0; i < m_farms.size(); i++)
        {
            if (a_farmref == m_farms[i]->GetFarmNumber())
            {
                return m_farms[i]->GetCentroids();
            }
        }
        g_msg->Warn("FarmManager::GetFarmCentroid - missing farm ref", a_farmref);
        exit(92);
    }
    bool IsDuplicateRef(int a_ref, HunterInfo* a_hinfo);
    double GetSpilledGrain();
    double GetSpilledMaize();
    void SetSpilledGrain( bool a_spilledgrain ) {
        m_SpilledGrain = a_spilledgrain;
    }
    double GetDD (void){return daydegrees;}; 
    void SetDD (double a_dd){daydegrees = a_dd;};
 
    int GetFarmNoLookupIndex(int a_ref) {
        for (int i = 0; i < (int)m_farms.size(); i++)
        {
            if (GetFarmNoLookup(i) == a_ref) return i;
        }
        g_msg->Warn("FarmManager::GetFarmNoLookupIndex: Farm ref not found", a_ref);
        exit(142);
    }
    int GetFarmNoLookup(int a_ref) { return m_farmmapping_lookup[a_ref * 2]; }
    int GetFarmTypeLookup(int a_ref) { return m_farmmapping_lookup[a_ref * 2 + 1]; }
    bool GetIsRenumbered() { return m_renumbered; }
    int GetRenumberedFarmRef(int a_farmref)
    {
        for (int i = 0; i < (int)m_farms.size(); i++)
        {
            if (m_farmmapping_lookup[i * 2] == a_farmref)
            {
                return i;
            }
        }
        g_msg->Warn( "FarmManager::GetRenumberedFarmRef(int a_farmref)  Farm reference number not found in m_farmmapping_lookup ", a_farmref );
        exit( 9 );
    }
    int GetNoFarms( ) {
        return (int)m_farms.size();
    }
 
    vector<Crop*>* GetCropMgtPlans(void) { return &m_cropprogs; }
    int GetCropMgtPlansIndex(TTypesOfVegetation a_tov) {
        for (unsigned int i = 0; i < m_cropprogs.size(); i++)
        {
            if (a_tov == m_cropprogs[i]->m_tov) return i;
        }
        g_msg->Warn(WARN_MSG, "Mismatch in rotation file looking for tov ", a_tov);
        exit(1);
    }
    TTypesOfCrops GetCropTypeFromPlan(TTypesOfVegetation a_tov) {
        return m_cropprogs[GetCropMgtPlansIndex(a_tov)]->GetCropType();
    }
    // Farmer management functions below here
    FarmerList* GetFarmerList() { return m_farmers; }
    Farmer* GetFarmer(int i) { return m_farmers->GetFarmer(i); }
    void SetFarmer(int i, Farmer* a_farmer) { ; }
    Farm* GetFarm(int i) { return m_farms[i]; }
    FarmFuncsCostBenefits Get_FarmFuncsCB(FarmToDo a_action) { return m_FarmFuncsCB[a_action]; }
    void Print_FarmerAttributes();
    void AddToManagementStats(FarmEvent* a_ev);
#ifdef __CALCULATE_MANAGEMENT_NORMS
    void OutputManagementNormStats();
#endif
 
    bool GetUseSocioEconomicFarmers() { return  m_UseSocioEconomicFarmers; }
 
    
protected:
    vector<Crop*> m_cropprogs;
    vector<Farm*> m_farms;
 
    static bool m_UseSocioEconomicFarmers;
 
    vector<double> m_YieldReturns;
    FarmerList* m_farmers;
    Landscape* m_landscape;
    vector<double> m_CropYieldProfit;
    double m_MangagementNorms[toc_Foobar][fmc_Foobar];
    void  CreateFarms( const char *a_farmfile );
    double daydegrees;
    bool m_SpilledGrain{false};
    int* m_farmmapping_lookup;
    bool m_renumbered;
#ifdef __CALCULATE_MANAGEMENT_NORMS
    int m_managementnormstats[toc_Foobar][fmc_Foobar+1];
#endif
 
    vector<FarmFuncsCostBenefits> m_FarmFuncsCB;
    string m_ManagementCategoryLabels[fmc_Foobar];
    static void SetUseSocioEconomics(bool a_flag) { m_UseSocioEconomicFarmers = a_flag; }
 
 
    /************************* Economics **********************************/
protected:
    void ReadYieldProfitData(string a_filename);
public:
    double GetIncome(TTypesOfCrops a_toc);
};
 
 
#endif // FARM_H