FarmManager Class Reference

The Farm Manager class. More...

#include <farm.h>

Classes
struct	PesticideData
	Struct used for storing data on pesticide usage throughout the whole simulation (one instance, m_crops_summary_BIs). More...

Public Member Functions
	FarmManager ()
	Farm manager constructor. More...
	~FarmManager ()
	Farm manager destructor. More...
void	FarmManagement ()
	Runs the daily farm management for each farm, but also calculates annual spilled grain and maize. More...
void	InitiateManagement (void)
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	TranslateCropCodes (std::string &str)
void	DumpFarmAreas ()
void	DumpFarmrefs ()
	dumps the farmrefs file to a standard named file More...
void	InitFarms ()
	Calls OptimisingFarm::Init for all optimising farms. More...
void	Save_diff_farm_types_areas ()
	Calculates and saves total areas of all optimising farms and specific farm types. More...
int	GetFarmTotalSize (int a_farmref)
	Returns the total farm area from the farm ref num. More...
int	GetFarmArableSize (int a_farmref)
	Returns the arable area from the farm ref num. More...
TTypesOfFarm	GetFarmType (int a_farmref)
	Returns the farm type from the farm ref num. More...
int	GetFarmNoFields (int a_farmref)
	Returns the number of fields owned by a from the farm ref num. More...
APoint	GetFarmValidCoords (int a_farmref)
	Returns the number of fields owned by a from the farm ref num. More...
int	GetFarmNoOpenFields (int a_farmref, int a_openness)
	Returns the number of fields with openness more than a_openness. More...
int	GetFarmAreaOpenFields (int a_farmref, int a_openness)
	Returns the area of fields with openness more than a_openness. More...
Farm *	GetFarmPtr (int a_owner)
	Returns the pointer to a farm with a specific number. More...
Farm *	GetFarmPtrIndex (int a_index)
	Returns the pointer to a farm with a specific index. More...
int	GetRandomFarmRefnum ()
	Returns a random farm reference number. More...
void	CalcCentroids ()
	calculate all farm centroids More...
bool	InIllegalList (int a_farm_ref, vector< int > *a_farmlist)
	Checks a list to see if a farm matches the illegal list of references. More...
void	AddToIllegalList (int a_farm_ref, vector< int > *a_farmlist)
	Add to a list if a farm is not already among the illegal list of references. More...
int	FindClosestFarm (HunterInfo a_hinfo, vector< int > *a_farmlist)
	Finds the closest farm to this co-ordinate. More...
int	FindClosestFarmOpenness (HunterInfo a_hinfo, vector< int > *a_farmlist, int a_openness)
	Finds the closest farm to this co-ordinate but uses a probability distribtution for acceptance. More...
int	FindClosestFarmOpennessProb (HunterInfo a_hinfo, vector< int > *a_farmlist, int a_openness)
	Finds the closest farm to this co-ordinate with openness more than a value but uses a probability distribtution for acceptance based on closeness. More...
int	FindClosestFarmOpennessProbSmallIsBest (HunterInfo a_hinfo, vector< int > *a_farmlist, int a_openness, vector< int > *a_farmsizelist)
	Finds the closest farm to this co-ordinate with openness more than a value but uses a probability distribtution for acceptance based on closeness and another based on farm size. More...
int	FindClosestFarmOpennessProbNearRoostIsBest (HunterInfo a_hinfo, vector< int > *a_farmlist, int a_openness, vector< APoint > *a_farmsizelist)
	Finds the closest farm to this co-ordinate with openness more than a value but uses a probability distribtution for acceptance based on closeness and another based on farm size. More...
int	FindFarmWithRandom (vector< int > *a_farmlist)
	Finds a farm openness more than a value not on the list. More...
int	FindFarmWithOpenness (vector< int > *a_farmlist, int a_openness)
	Finds a farm openness more than a value not on the list. More...
int	FindOpennessFarm (int a_openness)
	Finds a random farm with at least one field with openness above a_openness. More...
bool	CheckOpenness (int a_openness, int a_ref)
	Check if a farm has at least one field with openness above a_openness. More...
APoint	GetFarmCentroid (int a_farmref)
	Gets the farm centroid as an APoint. More...
bool	IsDuplicateRef (int a_ref, HunterInfo *a_hinfo)
	Checks if we already have this ref. More...
double	GetSpilledGrain ()
	Returns the average amount of spilled grain in KJ/m2 this year. More...
double	GetSpilledMaize ()
	Returns the average amount of spilled maize in KJ/m2 this year. More...
void	SetSpilledGrain (bool a_spilledgrain)
	Set m_SpilledGrain which is the flag for either 2013 (true) or 2014 (false) spilled grain distributions. More...
void	FindNeighbours ()
	Finds all OptimisingFarms' neighbours and saves them in the farm's OptimisingFarm::m_neighbours vector. More...
double	GetDD (void)
	Returnes day degrees for the period March 1st - November 1st. Used for determining yields of crops that are not harvested. More...
void	SetDD (double a_dd)
double	Get_cropTotals (int i)
void	Add_to_cropTotals (int i, double value)
void	Set_cropTotals (int i, double value)
int	Get_cropTotals_size ()
void	ActualProfit ()
	Calls OptimisingFarm::ActualProfit for all optimising farms. More...
void	ChooseDecisionMode_for_farms ()
	Calls OptimisingFarm::ChooseDecisionMode for all optimising farms. More...
void	Save_last_years_crops_for_farms ()
	Calls OptimisingFarm::Save_last_years_crops for all optimising farms. More...
void	PrintDecModes_counts ()
	For each OptimizingFarm it prints the number of times each of the decision modes was used within a single simulation. See also OptimisingFarm::m_decision_mode_counters. More...
void	PrintFinalResults ()
	At the end of a simulation it prints results on crop distribution, pesticide and fertilizer usage. More...
void	Switch_rotation ()
	Switches OptimisingFarms Farm::m_rotation to the list of all possible rotational crops. More...
TTypesOfVegetation	Get_crops_summary_BIs_tov (int i)
void	Set_crops_summary_BIs_herb (int i, double BIherb)
void	Set_crops_summary_BIs_fi (int i, double BIfi)
void	Set_crops_summary_BIs (int i, double BI)
void	Set_cropTotals_sum (int i, double crop_area)
void	Set_cropTotals_plant_sum (int i, double crop_area)
void	Set_cropTotals_pig_sum (int i, double crop_area)
void	Set_cropTotals_cattle_sum (int i, double crop_area)
void	Set_cropTotals_other_sum (int i, double crop_area)
void	Set_crops_fertilizer (int i, double fert)
void	Set_crops_fertilizer_trade (int i, double fert_trade)
TTypesOfOptFarms	TranslateFarmCodes (string &str)
TTypesOfSoils	TranslateSoilCodes (string &str)
TTypesOfFarmSize	TranslateFarmSizeCodes (string &str)
TTypesOfAnimals	TranslateAnimalsCodes (string &str)
TTypesOfCrops	TranslateCropsCodes (string &str)
TTypesOfParameters	TranslateParametersCodes (string &str)
TTypesOfLivestockParameters	TranslateLivestockParametersCodes (string &str)
TTypesOfCropVariables	TranslateCropVariablesCodes (string &str)
int	Get_lookup_table (int index)
int	GetFarmNoLookup (int a_ref)
	Get a farm reference from the lookup table. More...
int	GetFarmTypeLookup (int a_ref)
	Get a farm type from the lookup table. More...
bool	GetIsRenumbered ()
	Returns the flag for renumbering. More...
int	GetRenumberedFarmRef (int a_farmref)
	Returns the farm ref index for a farmref. More...
int	GetNoFarms ()

Public Attributes
DataForOptimisation *	pm_data
	Pointer to the DataForOptimisation. More...
ofstream *	pm_output_file

Protected Member Functions
void	CreateFarms (const char *a_farmfile)
void	ReadFarmsData ()
	Reads farm level parameters and saves them in a vector DataForOptimisation::m_farm_data. More...
void	ReadLivestockNumbers ()
	Reads the data on livestock numbers and saves them in a vector DataForOptimisation::m_livestockNumbers. More...
void	ReadInitialCropAreas ()
	Reads the data on farms' initial crop distributions and saves them in a vector DataForOptimisation::m_cropAreas. More...
void	ReadFarmsData_perFarmType ()
	Reads the data on farms' parameters that vary with a farm type and saves them in a vector of a DataForOptimisation class. More...
void	ReadLivestockData ()
	Reads the data on livestock parameters (do not vary with farm variables) and saves them in a vector DataForOptimisation::m_livestockParameters. More...
void	ReadCropsData ()
	Reads the data on crops' parameters that do not vary with farm variables and saves them in a vector DataForOptimisation::m_cropParameters. More...
void	ReadCropsData_perSoilType ()
	Reads the data on crops' parameters that vary with a soil type (alfa, beta1, beta2, Nnorm) and saves them in vectors of the DataForOptimisation class. More...
void	ReadCropsData_perFarmType ()
	Reads the data on crops' parameters that vary with a farm type (fixed, fodder, FUKey) and saves them in vectors of the DataForOptimisation class. More...
void	ReadCropsData_perFarm_and_Soil ()
	Reads the data on crops' parameters that vary with a farm and soil type (sellingPrice) and saves them in a vector DataForOptimisation::m_sellingPrice. More...
void	ReadCropsData_perFarm_and_Soil_and_Size ()
	Reads the data on crops' parameters that vary with a farm type, soil type and farm size (rotationMax, rotationMin) and saves them in vectors of the DataForOptimisation class. More...
void	ReadInitialCropAreas_almass ()
	Reads the data on farms' initial crop distributions and saves them in a vector of a DataForOptimisation class. ALMaSS crop mode. More...
void	ReadCropsData_almass ()
	Reads the data on crops' parameters that do not vary with farm variables and saves them in a vector DataForOptimisation::m_cropParameters. ALMaSS crop mode. More...
void	ReadCropsData_perSoilType_almass ()
	Reads the data on crops' parameters that vary with a soil type (alfa, beta1, beta2, Nnorm) and saves them in vectors of the DataForOptimisation class. ALMaSS crop mode. More...
void	ReadCropsData_perFarmType_almass ()
	Reads the data on crops' parameters that vary with a farm type (fixed, fodder, FUKey) and saves them in vectors of the DataForOptimisation class. ALMaSS crop mode. More...
void	ReadCropsData_perFarm_and_Soil_almass ()
	Reads the data on crops' parameters that vary with a farm and soil type (sellingPrice) and saves them in a vector DataForOptimisation:m_sellingPrice. ALMaSS crop mode. More...
void	ReadCropsData_perFarm_and_Soil_and_Size_almass ()
	Reads the data on crops' parameters that vary with a farm type, soil type and farm size (rotationMax, rotationMin) and saves them in vectors of the DataForOptimisation class. ALMaSS crop mode. More...
void	ReadEnergyMaizePrice ()
void	OptimisationOutput ()
	Creates output files for all crop level variables and for landscape level crop distribution. Includes results of the initial farm otpimisation. More...
void	PrintOutput (TTypesOfCropVariables a_var, string a_fileName)
	Makes an output file for one crop variable and prints its values for each crop and each OptimisingFarm. Includes results of the initial farm otpimisation. More...
void	CropDistribution ()
	Calculates total crop areas (at the landscape level). Includes results of the initial farm otpimisation. More...
void	Create_Output_file_for_farms ()
	Creates an output file. Prints the crop variables in the first row of the file. The file is used then by farms (OptimisingFarm) to print the farm level results of optimisation. Includes results of the initial farm otpimisation. More...
void	ReadLookupTable ()
	Reads the lookup table with allowed/forbidden crop order from a text file and saves it into a vector m_crop_lookup_table. More...
void	PrintNeighbours ()
	Creates an output file with a list of neighbours of each OptimisingFarm. More...
void	DistributeFarmerTypes ()
	Randomly assigns farmer types to farms (OptimisingFarm) in proportions specified in an input file. More...

Protected Attributes
vector< Farm * >	m_farms
Population_Manager *	m_population_manager
double	daydegrees
	Daydegress for period March 1st - November 1st. Used to determine yield of crops that are not harvested (and thus do not have values of biomass at harvest). More...
bool	m_SpilledGrain
	Is it 2013 (true) or 2014 (false) as far as grain goes. More...
int *	m_farmmapping_lookup
	Used for a dynamic array of lookups converting farm references to internal renumbering. More...
bool	m_renumbered
	A flag to show whether renumbering was already done. More...
double	totalOptFarmsArea
double	totalOptFarmsArea_plant
double	totalOptFarmsArea_pig
double	totalOptFarmsArea_cattle
double	totalOptFarmsArea_other
vector< double >	m_cropTotals
	Stores crops areas at the landscape level per year. More...
vector< int >	m_crop_lookup_table
	Specifies which crop order is allowed in a rotation (i.e. if a given crop can follow another crop). More...
vector< double >	m_cropTotals_sum
	Stores the sums of crops areas within one simulation at the landscape level. More...
vector< double >	m_cropTotals_plant_sum
	Stores the sums of crops areas on plant farms within one simulation at the landscape level. More...
vector< double >	m_cropTotals_pig_sum
	Stores the sums of crops areas on pig farms within one simulation at the landscape level. More...
vector< double >	m_cropTotals_cattle_sum
	Stores the sums of crops areas on cattle farms within one simulation at the landscape level. More...
vector< double >	m_cropTotals_other_sum
	Stores the sums of crops areas on other farms within one simulation at the landscape level. More...
vector< PesticideData >	m_crops_summary_BIs
	Stores information on aggregate (all farms)pesticide usage for each crop. More...
vector< double >	m_crops_fertilizer
	Stores information on aggregate (all farms) fertilizer usage for each crop. More...
vector< double >	m_crops_fertilizer_trade
	Stores information on aggregate (all farms) fertilizer trade (Nt) usage for each crop. More...
vector< double >	m_crop_areas_stages
	Stores information on crop areas calculated in different stages of model development: for comparison in sensitivity analysis. More...

Detailed Description

The Farm Manager class.

Definition at line 1563 of file farm.h.

Constructor & Destructor Documentation

FarmManager::FarmManager

(

)

Farm manager constructor.

Definition at line 2177 of file farm.cpp.

References cfg_MaizeEnergy, cfg_OptimiseBedriftsmodelCrops, cfg_OptimisingFarms, l_map_farmref_file, l_map_read_farmfile, CfgBool::value(), and CfgStr::value().

{

    g_farmmanager = this;

    if ( l_map_read_farmfile.value() ) {
        if (cfg_OptimisingFarms.value()){
            //make a data object
            pm_data=new DataForOptimisation;
            ReadFarmsData();
            ReadLivestockNumbers();
            ReadFarmsData_perFarmType();
            ReadLivestockData();
            //ReadGlobalData();
            ReadLookupTable();
            ofstream ofile ("Economic_figures.txt", ios::out);
            ofile.close();      
            ofstream ofile1 ("Daydegrees.txt", ios::out);
            ofile1.close();
            if(cfg_MaizeEnergy.value()){
                ofstream ofileEM ("Maize_energy_price_yearly.txt", ios::out);
                ofileEM.close();
            }

            if (cfg_OptimiseBedriftsmodelCrops.value()){
                ReadInitialCropAreas();
                ReadCropsData();
                ReadCropsData_perSoilType();
                ReadCropsData_perFarmType();
                ReadCropsData_perFarm_and_Soil();
                ReadCropsData_perFarm_and_Soil_and_Size();
            }
            else{
                ReadInitialCropAreas_almass();
                ReadCropsData_almass();
                ReadCropsData_perSoilType_almass();
                ReadCropsData_perFarmType_almass();
                ReadCropsData_perFarm_and_Soil_almass();
                ReadCropsData_perFarm_and_Soil_and_Size_almass();
                m_crops_summary_BIs.resize(pm_data->Get_noCrops()); //no_crops - from the input file on initial crop areas
                m_cropTotals_sum.resize(pm_data->Get_noCrops());
                m_cropTotals_plant_sum.resize(pm_data->Get_noCrops());
                m_cropTotals_pig_sum.resize(pm_data->Get_noCrops());
                m_cropTotals_cattle_sum.resize(pm_data->Get_noCrops());
                m_cropTotals_other_sum.resize(pm_data->Get_noCrops());
                m_crops_fertilizer.resize(pm_data->Get_noCrops());
                m_crops_fertilizer_trade.resize(pm_data->Get_noCrops());
                m_crop_areas_stages.resize( 2 * pm_data->Get_noCrops()); //use just the results of the baseline and original model
                for(int i=0; i<pm_data->Get_noCrops(); i++){
                    m_crops_summary_BIs[i].Tov = pm_data->Get_cropTypes_almass(i);
                    m_crops_summary_BIs[i].BI=0;
                    m_crops_summary_BIs[i].BIherb=0;
                    m_crops_summary_BIs[i].BIfi=0;
                    m_cropTotals_sum[i]=0;
                    m_cropTotals_plant_sum[i]=0;
                    m_cropTotals_pig_sum[i]=0;
                    m_cropTotals_cattle_sum[i]=0;
                    m_cropTotals_other_sum[i]=0;
                    m_crops_fertilizer[i]=0;
                    m_crops_fertilizer_trade[i]=0;
                }

                if(cfg_MaizeEnergy.value()){
                  ReadEnergyMaizePrice();
                }
            }
        }//if optimising farm
        CreateFarms( l_map_farmref_file.value() );
    }

}

FarmManager::~FarmManager

(

)

Farm manager destructor.

Definition at line 2250 of file farm.cpp.

References cfg_OptimisingFarms, and CfgBool::value().

{

    for ( unsigned int i = 0; i < m_farms.size(); i++ )
        delete m_farms[ i ];
    if (cfg_OptimisingFarms.value()) delete pm_data;
}

Member Function Documentation

void FarmManager::ActualProfit

(

)

Calls OptimisingFarm::ActualProfit for all optimising farms.

Definition at line 2956 of file farm.cpp.

References OptimisingFarm::ActualProfit(), Farm::GetType(), and tof_OptimisingFarm.

                              {

    for(int i=0; i<(int)m_farms.size(); i++){
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            OptimisingFarm * opf;
            opf =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            opf->ActualProfit();
        }
    }
}

void FarmManager::Add_to_cropTotals ( int  i, double  value  )

inline

Definition at line 1695 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_cropTotals[i] += value;};

void FarmManager::AddField	(	int	a_OwnerIndex,
		LE *	a_newland,
		int	a_Owner
	)

Definition at line 2292 of file farm.cpp.

References LE::SetOwner().

{
    m_farms[ a_OwnerIndex ]->AddField( a_newland );
    a_newland->SetOwner( m_farms[ a_OwnerIndex ], a_Owner, a_OwnerIndex );
}

void FarmManager::AddToIllegalList	(	int	a_farm_ref,
		vector< int > *	a_farmlist
	)

Add to a list if a farm is not already among the illegal list of references.

a_farmlist is a pointer to a list of integers with illegal farm ref numbers.

Definition at line 2622 of file farm.cpp.

                                                                             {
    bool found = false;
    unsigned sz = (unsigned)a_farmlist->size();
    for (unsigned f = 0; f < sz; f++) {
        if ((*a_farmlist)[f] == a_farm_ref) {
            found = true;
            break;
        }
    }
    if (!found) {
        a_farmlist->push_back( a_farm_ref );
    }
}

void FarmManager::CalcCentroids ( )

inline

calculate all farm centroids

Definition at line 1640 of file farm.h.

{ for (unsigned int i = 0; i < m_farms.size(); i++) m_farms[i]->Centroids(); }

bool FarmManager::CheckOpenness	(	int	a_openness,
		int	a_ref
	)

Check if a farm has at least one field with openness above a_openness.

Definition at line 2922 of file farm.cpp.

References Farm::GetMaxOpenness().

                                                           {
    if (m_farms[ a_ref ]->GetMaxOpenness() > a_openness) return true;
    return false;
}

void FarmManager::ChooseDecisionMode_for_farms

(

)

Calls OptimisingFarm::ChooseDecisionMode for all optimising farms.

Definition at line 2967 of file farm.cpp.

References OptimisingFarm::ChooseDecisionMode(), Farm::GetType(), and tof_OptimisingFarm.

                                              {

    for(int i=0; i<(int)m_farms.size(); i++){
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            OptimisingFarm * opf;
            opf =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            opf->ChooseDecisionMode();

        }
    }
}

int FarmManager::ConnectFarm

(

int

a_owner

)

Definition at line 2303 of file farm.cpp.

References g_msg, Farm::GetFarmNumber(), MapErrorMsg::Warn(), and WARN_FILE.

{
  for ( unsigned int i = 0; i < m_farms.size(); i++ )
  {
    if ( a_owner == m_farms[ i ]->GetFarmNumber() )
    {
      // Found it. Set mapping and return.
      return i;
    }
  }
  // We didn't find the owner in the list of farms,
  // pregenerated in CreateFarms() above. Something
  // is not correct here, so raise an appropriate
  // error and exit.
  char error_num[ 20 ];
  sprintf( error_num, "%d", a_owner );
  g_msg->Warn( WARN_FILE, "FarmManager::ConnectFarm(): Unknown farm number"" referenced in polygon file:", error_num );
  exit( 1 );
}

void FarmManager::Create_Output_file_for_farms ( )

protected

Creates an output file. Prints the crop variables in the first row of the file. The file is used then by farms (OptimisingFarm) to print the farm level results of optimisation. Includes results of the initial farm otpimisation.

Definition at line 4132 of file farm.cpp.

                                              {

    pm_output_file = new ofstream ("FarmVariables.txt", ios::out);

    (*pm_output_file) << "Farm no \t";

    //print variables' names (18 variables, 09.05.12)
    (*pm_output_file) << "mainGoal \t" << "totalArea \t" << "totalIncome \t" << "totalCosts \t" << "totalProfit \t";
    (*pm_output_file) << "FodderDemand \t" << "FodderDemand_bef \t" << "FodderTrade \t" << "FodderGrown \t" ;
    (*pm_output_file) << "Nanim \t" << "totalNanim \t" << "totalNt \t" << "totalN \t" ;
    (*pm_output_file) << "totalBI \t" << "totalBIHerb \t" << "totalBIFi \t" ;
    (*pm_output_file) << "totalGrooming \t" << "totalHoeing \t" << "totalWeeding \t";
    (*pm_output_file) << endl;

}

void FarmManager::CreateFarms ( const char *  a_farmfile )

protected

Definition at line 2323 of file farm.cpp.

References cfg_OptimisingFarms, g_farm_fixed_rotation_enable, g_farm_fixed_rotation_farmtype, g_msg, toof_Cattle, toof_Other, toof_Pig, toof_Plant, UserDefinedFarm35::UserDefinedFarm35(), CfgInt::value(), CfgBool::value(), MapErrorMsg::Warn(), and WARN_FILE.

{
    int No, FType, NoFarms;
    FILE * inpf = fopen(a_farmfile, "r" );
    if (!inpf) {
        g_msg->Warn( WARN_FILE, "Landscape::CreateFarms(): Unable to open file", a_farmfile );
        exit( 1 );
    }

    fscanf( inpf, "%d", & NoFarms );

    m_farms.resize( NoFarms );

    m_farmmapping_lookup = new int[NoFarms * 2];

    for (int i = 0; i < NoFarms; i++)
    {
        // File format:
        //
        // Two colunms of numbers 0..number of farms, 0-number of farmtypes-1
        // the second column determines what type of farm we have
        fscanf(inpf, "%d %d", &No, &FType);
        m_farmmapping_lookup[i * 2] = No;
        m_farmmapping_lookup[i * 2 + 1] = FType;
    }
    fclose(inpf);

    for (int i = 0; i < NoFarms; i++)
    {
        /*
        //If we are testing crop management, then ignore farm type from
        // the file and set to fixed one instead.
        if ( g_farm_test_crop.value() ) {
        FType = g_farm_test_crop_farmtype.value();
        }
        */
        // If we are running in fixed, sync'ed rotation mode, set all farms to
        // be of the requested type.
        if (g_farm_fixed_rotation_enable.value()) {
            FType = g_farm_fixed_rotation_farmtype.value();
        }

        switch (m_farmmapping_lookup[i * 2 + 1]) // FType
        {
        case 0:
            m_farms[i] = new ConventionalCattle(this);
            break;
        case 1:
            m_farms[i] = new ConventionalPig(this);
            break;
        case 2:
            m_farms[i] = new ConventionalPlant(this);
            break;
        case 3:
            m_farms[i] = new OrganicCattle(this);
            break;
        case 4:
            m_farms[i] = new OrganicPig(this);
            break;
        case 5:
            m_farms[i] = new OrganicPlant(this);
            break;
        case 6:
            m_farms[i] = new PesticideTrialControl(this);
            break;
        case 7:
            m_farms[i] = new PesticideTrialToxicControl(this);
            break;
        case 8:
            m_farms[i] = new PesticideTrialTreatment(this);
            break;
        case 9:
            m_farms[i] = new ConvMarginalJord(this);
            break;
        case 10:
            m_farms[i] = new AgroChemIndustryCerealFarm1(this);
            break;
        case 11:
            m_farms[i] = new AgroChemIndustryCerealFarm2(this);
            break;
        case 12:
            m_farms[i] = new AgroChemIndustryCerealFarm3(this);
            break;
        case 13:
            m_farms[i] = new NoPesticideBaseFarm(this);
            break;
        case 14:
            m_farms[i] = new NoPesticideNoPFarm(this);
            break;
        case 15:
            m_farms[i] = new UserDefinedFarm1(this);
            break;
        case 16:
            m_farms[i] = new UserDefinedFarm2(this);
            break;
        case 17:
            m_farms[i] = new UserDefinedFarm3(this);
            break;
        case 18:
            m_farms[i] = new UserDefinedFarm4(this);
            break;
        case 19:
            m_farms[i] = new UserDefinedFarm5(this);
            break;
        case 20:
            m_farms[i] = new UserDefinedFarm6(this);
            break;
        case 21:
            m_farms[i] = new UserDefinedFarm7(this);
            break;
        case 22:
            m_farms[i] = new UserDefinedFarm8(this);
            break;
        case 23:
            m_farms[i] = new UserDefinedFarm9(this);
            break;
        case 24:
            m_farms[i] = new UserDefinedFarm10(this);
            break;
        case 25:
            m_farms[i] = new UserDefinedFarm11(this);
            break;
        case 26:
            m_farms[i] = new UserDefinedFarm12(this);
            break;
        case 27:
            m_farms[i] = new UserDefinedFarm13(this);
            break;
        case 28:
            m_farms[i] = new UserDefinedFarm14(this);
            break;
        case 29:
            m_farms[i] = new UserDefinedFarm15(this);
            break;
        case 30:
            m_farms[i] = new UserDefinedFarm16(this);
            break;
        case 31:
            m_farms[i] = new UserDefinedFarm17(this);
            break;
            // NB the user defing farms below require an extra parameter in the rotation file denoting the intensity (0 or 1 = high low)
        case 32:
            m_farms[i] = new UserDefinedFarm18("UserDefinedFarm18.rot", this);
            break;
        case 33:
            m_farms[i] = new UserDefinedFarm19("UserDefinedFarm19.rot", this);
            break;
        case 34:
            m_farms[i] = new UserDefinedFarm20("UserDefinedFarm20.rot", this);
            break;
        case 35:
            m_farms[i] = new UserDefinedFarm21("UserDefinedFarm21.rot", this);
            break;
        case 36:
            m_farms[i] = new UserDefinedFarm22("UserDefinedFarm22.rot", this);
            break;
        case 37:
            m_farms[i] = new UserDefinedFarm23("UserDefinedFarm23.rot", this);
            break;
        case 38:
            m_farms[i] = new UserDefinedFarm24("UserDefinedFarm24.rot", this);
            break;
        case 39:
            m_farms[i] = new UserDefinedFarm25("UserDefinedFarm25.rot", this);
            break;
        case 40:
            m_farms[i] = new UserDefinedFarm26("UserDefinedFarm26.rot", this);
            break;
        case 41:
            m_farms[i] = new UserDefinedFarm27("UserDefinedFarm27.rot", this);
            break;
        case 42:
            m_farms[i] = new UserDefinedFarm28("UserDefinedFarm28.rot", this);
            break;
        case 43:
            m_farms[i] = new UserDefinedFarm29("UserDefinedFarm29.rot", this);
            break;
        case 44:
            m_farms[i] = new UserDefinedFarm30("UserDefinedFarm30.rot", this);
            break;
        case 45:
            m_farms[i] = new UserDefinedFarm31("UserDefinedFarm31.rot", this);
            break;
        case 46:
            m_farms[i] = new UserDefinedFarm32("UserDefinedFarm32.rot", this);
            break;
        case 47:
            m_farms[i] = new UserDefinedFarm33("UserDefinedFarm33.rot", this);
            break;
        case 48:
            m_farms[i] = new UserDefinedFarm34("UserDefinedFarm34.rot", this);
            break;
        case 49:
            m_farms[i] = new UserDefinedFarm35("UserDefinedFarm35.rot", this);
            break;
        case 50: //optimising farm!
            if ((pm_data->Get_farmType(No)) == toof_Pig) {
                m_farms[i] = new OptimisingPigFarm(this, No);
            }
            else if ((pm_data->Get_farmType(No)) == toof_Cattle){
                m_farms[i] = new OptimisingCattleFarm(this, No);
            }
            else if ((pm_data->Get_farmType(No)) == toof_Plant){
                m_farms[i] = new OptimisingPlantFarm(this, No);
            }
            else if ((pm_data->Get_farmType(No)) == toof_Other){
                m_farms[i] = new OptimisingOtherFarm(this, No);
            }
            break;

        default:
            g_msg->Warn(WARN_FILE, "Landscape::CreateFarms(): Unknown farm ""type reference number", "");
            exit(1);
        }
        m_farms[i]->SetFarmNumber(i); // We use 'i' here because we renumber the farms internally. If the file did not come in this way then a dump file is created - tested in ReadPolys2
    }

    if(cfg_OptimisingFarms.value())
    {
        DistributeFarmerTypes(); //added 240513
    }

    if (GetFarmNoLookup(NoFarms - 1) != NoFarms - 1) m_renumbered = false; else m_renumbered = true;
}

void FarmManager::CropDistribution ( )

protected

Calculates total crop areas (at the landscape level). Includes results of the initial farm otpimisation.

Definition at line 4111 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, OptimisingFarm::Get_crop(), OptimisingFarm::Get_cropsSize(), Farm::GetType(), CropOptimised::m_area_ha, toc_Foobar, tof_OptimisingFarm, and CfgBool::value().

                                  {

    int no_crops = (cfg_OptimiseBedriftsmodelCrops.value())? toc_Foobar : pm_data->Get_noCrops(); //bedriftsmodel crops/almass crops
    m_cropTotals.resize(no_crops); //no_crops is ok for both almass and bedriftsmodel crop mode; it is taken from the input file on initial crop areas

    for(int i=0; i<(int)m_farms.size(); i++){

        OptimisingFarm * opf;
        int size=0;
        if(m_farms[i]->GetType()==tof_OptimisingFarm) { //take only optimising farms
            opf =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            size = opf->Get_cropsSize(); 
            for(int j=0; j<size; j++) {
                CropOptimised *crop = opf->Get_crop(j);
                double area = crop->m_area_ha;
                m_cropTotals[j] += area;
            }
        }
    }
}

void FarmManager::DistributeFarmerTypes ( )

protected

Randomly assigns farmer types to farms (OptimisingFarm) in proportions specified in an input file.

Definition at line 4488 of file farm.cpp.

References cfg_Environmentalist_proportion, cfg_Profit_max_proportion, cfg_Yield_max_proportion, Farm::GetType(), tof_OptimisingFarm, tofg_environment, tofg_profit, tofg_yield, and CfgFloat::value().

                                       {

    //get the shares of certain types. Parameters in the config file.
    double profit_proportion = cfg_Profit_max_proportion.value(); 
    double yield_proportion = cfg_Yield_max_proportion.value(); 
    double env_proportion = cfg_Environmentalist_proportion.value(); 

    //get the number of optimising farms (count them) and make a list of opt farms and its copy
    int number_opt_farms=0;
    vector <OptimisingFarm*> opt_farms;
    vector <OptimisingFarm*> opt_farms_copy;
    for(int i=0; i<(int)m_farms.size(); i++){
        if(m_farms[i]->GetType()==tof_OptimisingFarm){
            number_opt_farms++;
            OptimisingFarm * opf =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            opt_farms.push_back(opf);
        }
    }
    opt_farms_copy = opt_farms;

    //find the number of farms that should be of a certain type
    int number_profit = (int) (profit_proportion/100 *  number_opt_farms); // + 0.5); round down - to avoid having a total number of diff types higher than the number of farms
    int number_yield = (int) (yield_proportion/100 *  number_opt_farms + 0.5);
    int number_env = (int) (env_proportion/100 *  number_opt_farms + 0.5);

    //see: http://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution
    random_device rd;
    mt19937 gen(rd());

    int jj=0;
    int index_for_farm=0;

    //set farms with profit as a main goal
    for(int j=jj; j<number_profit; j++){
         distribution_type2 dis(0, number_opt_farms - j - 1); //each time we remove one farm, so '-j' and '-1' casue the last element in the list is =size-1.
         index_for_farm  = dis(gen);
         opt_farms_copy[index_for_farm]->Set_main_goal(tofg_profit);
         opt_farms_copy.erase(opt_farms_copy.begin() + index_for_farm); //remove the farm from the list after assignign the goal
         jj = j;
    }
    jj++; //need to increase by one here!

    //set farms with yield as a main goal
    for(int j = jj; j<number_yield + number_profit; j++){ //start with the value of 'i' as it was after leaving the last for loop!
        distribution_type2 dis1(0, number_opt_farms - j - 1); //each time we remove one farm, so '-j'
         index_for_farm  = dis1(gen);
         opt_farms_copy[index_for_farm]->Set_main_goal(tofg_yield);
         opt_farms_copy.erase(opt_farms_copy.begin() + index_for_farm); //remove the farm from the list after assignign the goal
         jj = j;
    }
    jj++;

    //set farms with environment as a main goal
    int loop_limit = (number_env + number_profit + number_yield > number_opt_farms)? number_opt_farms : number_env + number_profit + number_yield;
    for(int j=jj; j<loop_limit; j++){
        distribution_type2 dis2(0, number_opt_farms - j - 1); //each time we remove one farm, so '-j'
         index_for_farm  = dis2(gen);
         opt_farms_copy[index_for_farm]->Set_main_goal(tofg_environment);
         opt_farms_copy.erase(opt_farms_copy.begin() + index_for_farm); //remove the farm from the list after assignign the goal
    }

    //check if there are any farms left without assigned goal
    if((int)opt_farms_copy.size()>0){ //it should be not more than 1-2
        for(int p=(int)opt_farms_copy.size(); p>0; p--){
            opt_farms_copy[p-1]->Set_main_goal(tofg_profit);
        }
    }

}

void FarmManager::DumpFarmAreas

(

)

Definition at line 1536 of file farm.cpp.

References OptimisingFarm::Get_almass_no(), Farm::GetArea(), and tof_OptimisingFarm.

                               {

    //create a text file with the farms
    ofstream ofile ("FarmTotalAreas_almass.txt", ios::out);
    ofile << "Farm no" << '\t' << "Area" << endl;

    //print each farms no and then the numbers of its neighbours
    for(int i=0; i<(int)m_farms.size(); i++){
        OptimisingFarm * opf_i;
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            opf_i =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            ofile << opf_i->Get_almass_no() << '\t';
            ofile << opf_i->GetArea() <<'\t';
            ofile  << endl;
        }
    }
}

void FarmManager::DumpFarmrefs

(

)

dumps the farmrefs file to a standard named file

Definition at line 2548 of file farm.cpp.

References g_msg, MapErrorMsg::Warn(), and WARN_FILE.

{
    ofstream opf("dump_farmrefs.txt");
    if (!opf.is_open())
    {
        g_msg->Warn(WARN_FILE, "Landscape::CreateFarms(): Unable to open file", "dump_farmrefs.txt");
        exit(1);
    }
    int NoFarms = (int) m_farms.size();
    opf << NoFarms << endl;
    for (int i = 0; i < NoFarms; i++)
    {
        opf << i << '\t' << m_farmmapping_lookup[i * 2 + 1] << endl;
    }
    opf.close();
}

void FarmManager::FarmManagement

(

)

Runs the daily farm management for each farm, but also calculates annual spilled grain and maize.

Definition at line 2258 of file farm.cpp.

References cfg_Animals_number_test_day, cfg_AnimalsThreshold, cfg_LifeStage, OptimisingFarm::Get_main_goal(), Farm::GetFarmNumber(), Farm::GetType(), OptimisingFarm::Set_animals_no(), Landscape::SupplyDayInYear(), Landscape::SupplyFarmAnimalCensus(), Landscape::SupplyYearNumber(), tof_OptimisingFarm, tofg_environment, CfgInt::value(), and CfgFloat::value().

{
    for ( unsigned int i = 0; i < m_farms.size(); i++ )
    {
        m_farms[ i ]->Management();
    }

    //050214
    if(g_landscape_p->SupplyYearNumber()>0){
        if(g_landscape_p->SupplyDayInYear() == cfg_Animals_number_test_day.value()){ //check if this is the day we want to collect data on animal numbers
            for ( unsigned int i = 0; i < m_farms.size(); i++ )
            {
                OptimisingFarm * opf;
                if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
                    opf =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
                    if(cfg_AnimalsThreshold.value() > 0 && opf->Get_main_goal() == tofg_environment){ //take only environmentalists and check if we are in the feedback mode (no if the config is zero)
                        int farm_ref = opf->GetFarmNumber();
                        int animals_no = g_landscape_p->SupplyFarmAnimalCensus(farm_ref, cfg_LifeStage.value());
                        opf->Set_animals_no(animals_no);
                    }
                }
            }
        }
    }
}

int FarmManager::FindClosestFarm	(	HunterInfo	a_hinfo,
		vector< int > *	a_farmlist
	)

Finds the closest farm to this co-ordinate.

Centroid calculation on farms must be called before calling this method for the first time.
a_farmlist is a pointer to a list of integers with illegal farm ref numbers. The first entry lists the number of illegal numbers.

Definition at line 2649 of file farm.cpp.

References g_msg, HunterInfo::homeX, HunterInfo::homeY, and MapErrorMsg::Warn().

                                                                             {
    double best = 99999999999999999.0;
    int bestref = -1;
    double dist = best;
    for (unsigned i = 0; i < m_farms.size(); i++) {
        int fnum = m_farms[i]->GetFarmNumber();
        if (!InIllegalList(fnum, a_farmlist)) {
            if (!IsDuplicateRef(fnum, &a_hinfo)) {
                // Is possible to use this farm, so test it.
                APoint FPt = m_farms[i]->GetCentroids();
                dist = sqrt((double( FPt.m_x - a_hinfo.homeX ) * double( FPt.m_x - a_hinfo.homeX ) + double( FPt.m_y - a_hinfo.homeY ) * double( FPt.m_y - a_hinfo.homeY )));
                if (dist < best) {
                    best = dist;
                    bestref = fnum;
                }
            }
        }
    }
    if (bestref == -1) {
        g_msg->Warn( "FarmManager::FindClosestFarm - Cannot find open farm.", "" );
        exit( 0 );
    }
    return bestref;
}

int FarmManager::FindClosestFarmOpenness	(	HunterInfo	a_hinfo,
		vector< int > *	a_farmlist,
		int	a_openness
	)

Finds the closest farm to this co-ordinate but uses a probability distribtution for acceptance.

Finds the closest farm to this co-ordinate with openness more than a value

Definition at line 2678 of file farm.cpp.

References g_msg, Farm::GetMaxOpenness(), HunterInfo::homeX, HunterInfo::homeY, and MapErrorMsg::Warn().

                                                                                                            {
    // Centroid calculation on farms must be called before calling this method for the first time
    double best = 99999999999999999.0;
    int bestref = -1;
    double dist = best;
    for (unsigned i = 0; i < m_farms.size(); i++) {
        if (m_farms[ i ]->GetMaxOpenness() > a_openness) {
            int fref = m_farms[ i ]->GetFarmNumber();
            if (!InIllegalList( fref, a_farmlist )) {
                if (!IsDuplicateRef( fref, &a_hunterinfo )) {
                    APoint FPt = m_farms[ i ]->GetCentroids();
                    dist = sqrt( (double( FPt.m_x - a_hunterinfo.homeX ) * double( FPt.m_x - a_hunterinfo.homeX ) + double( FPt.m_y - a_hunterinfo.homeY ) * double( FPt.m_y - a_hunterinfo.homeY )) );
                    if (dist < best) {
                        best = dist;
                        bestref = fref;
                    }
                }
            }
        }
    }
    if (bestref == -1) {
        g_msg->Warn( "FarmManager::FindClosestFarmOpenness( ) - Cannot find open farm.", "" );
        exit( 0 );
    }
    return bestref;
}

int FarmManager::FindClosestFarmOpennessProb	(	HunterInfo	a_hinfo,
		vector< int > *	a_farmlist,
		int	a_openness
	)

Finds the closest farm to this co-ordinate with openness more than a value but uses a probability distribtution for acceptance based on closeness.

Centroid calculation on farms must be called before calling this method for the first time.
a_farmlist is a pointer to a list of integers with illegal farm ref numbers. The first entry lists the number of illegal numbers. The chance of acceptance is probability based, taking the nearest farm first then testing the next etc.. The probability is based on y = 1*EXP(-x*cfg) with cfg being a fitting parameter in cfg_ClosestFarmProbParam1

We use typedef here to create our own name for APoint - but it is just two unsigned ints. We will use 'x' for the farm num and 'y' for the distance.

We use a vector of AFarmDists to be able to sort it easily

Struct redefining operator < - used for sorting distances from smallest to largest.

Definition at line 2705 of file farm.cpp.

References cfg_ClosestFarmProbParam1, cfg_ClosestFarmProbParam2, g_msg, g_rand_uni, Farm::GetMaxOpenness(), HunterInfo::homeX, HunterInfo::homeY, CfgFloat::value(), and MapErrorMsg::Warn().

                                                                                                                {
    typedef  APoint AFarmDist;
    vector <AFarmDist> farmdists;
    struct FarmDistSort {
        bool operator()( AFarmDist a, AFarmDist b ) {
            return a.m_y < b.m_y;
        }
    };
    for (unsigned i = 0; i < m_farms.size(); i++) {
        int fnum = m_farms[ i ]->GetFarmNumber();
        if (!InIllegalList( fnum, a_farmlist )) {
            if (m_farms[ i ]->GetMaxOpenness() > a_openness) {
                if (!IsDuplicateRef( fnum, &a_hunterinfo )) {
                    // Is possible to use this farm, so test it.
                    APoint FPt = m_farms[ i ]->GetCentroids();
                    int dist = int(sqrt( (double( FPt.m_x - a_hunterinfo.homeX ) * double( FPt.m_x - a_hunterinfo.homeX ) + double( FPt.m_y - a_hunterinfo.homeY ) * double( FPt.m_y - a_hunterinfo.homeY )) ));
                    if (dist>40000) dist = 40000;
                    AFarmDist fd( int( fnum ), dist );
                    farmdists.push_back( fd );
                }
            }
        }
    }
    // By here we have a list of farms and their distances - now we have the option to sort it or randomise it - one or other line below should be commented out.
    // sort(farmdists.begin(), farmdists.end(), FarmDistSort()); // Sort
    random_shuffle( farmdists.begin(), farmdists.end() ); // Randomise
    // Now the vector is sorted/randomised we loop through and test probabilities
    for (int ch = 1; ch < 100000; ch++) // This loop just makes sure small chances don't mess up the run by tripping out early
    {
        int sz = int( farmdists.size() );
        for (int i = 0; i < sz; i++) {
            double chance = g_rand_uni();
            // Uses ch from the outer loop to scale probabilities - tripping out here will occur often for farms a long way from the area otherwise
            double calc = cfg_ClosestFarmProbParam2.value()* exp( (cfg_ClosestFarmProbParam1.value() / double( ch ))* farmdists[ i ].m_y );
            if (chance <= calc) return farmdists[ i ].m_x;
        }
    }
    g_msg->Warn( "FarmManager::FindClosestFarmProb", "- No suitable farm found" );
    exit( 0 );
}

int FarmManager::FindClosestFarmOpennessProbNearRoostIsBest	(	HunterInfo	a_hinfo,
		vector< int > *	a_farmlist,
		int	a_openness,
		vector< APoint > *	a_farmsizelist
	)

Finds the closest farm to this co-ordinate with openness more than a value but uses a probability distribtution for acceptance based on closeness and another based on farm size.

Centroid calculation on farms must be called before calling this method for the first time.
a_farmlist is a pointer to a list of integers with illegal farm ref numbers. The first entry lists the number of illegal numbers. The chance of acceptance is probability based, taking the nearest farm first then testing the next etc.. The probability is based on y = 1*EXP(-x*cfg) with cfg being a fitting parameter in cfg_ClosestFarmProbParam1

We use typedef here to create our own name for APoint - but it is just two unsigned ints. We will use 'x' for the farm num and 'y' for the distance.

We use a vector of AFarmDists to be able to sort it easily

Struct redefining operator < - used for sorting distances from smallest to largest.

Definition at line 2812 of file farm.cpp.

References cfg_ClosestFarmProbParam1, cfg_ClosestFarmProbParam2, cfg_RoostDistProbParam1, g_msg, g_rand_uni, Farm::GetMaxOpenness(), HunterInfo::homeX, HunterInfo::homeY, CfgFloat::value(), and MapErrorMsg::Warn().

                                                                                                                                                            {
    typedef  APoint AFarmDist;
    vector <AFarmDist> farmdists;
    struct FarmDistSort {
        bool operator()( AFarmDist a, AFarmDist b ) {
            return a.m_y < b.m_y;
        }
    };
    for (unsigned i = 0; i < m_farms.size(); i++) {
        int fnum = m_farms[ i ]->GetFarmNumber();
        if (!InIllegalList( fnum, a_farmlist )) {
            if (m_farms[ i ]->GetMaxOpenness() > a_openness) {
                if (!IsDuplicateRef( fnum, &a_hunterinfo )) {
                    // Is possible to use this farm, so test it.
                    APoint FPt = m_farms[ i ]->GetCentroids();
                    int dist = int(sqrt( (double( FPt.m_x - a_hunterinfo.homeX ) * double( FPt.m_x - a_hunterinfo.homeX ) + double( FPt.m_y - a_hunterinfo.homeY ) * double( FPt.m_y - a_hunterinfo.homeY )) ));
                    if (dist>40000) dist = 40000;
                    AFarmDist fd( unsigned( fnum ), dist );
                    farmdists.push_back( fd );
                }
            }
        }
    }
    // By here we have a list of farms and their distances - now we have the option to sort it or randomise it - one or other line below should be commented out.
    // sort(farmdists.begin(), farmdists.end(), FarmDistSort()); // Sort
    random_shuffle( farmdists.begin(), farmdists.end() ); // Randomise
    // Now the vector is sorted/randomised we loop through and test probabilities
    for (int ch = 1; ch < 100000; ch++) // This loop just makes sure small chances don't mess up the run by tripping out early
    {
        int sz = int( farmdists.size() );
        for (int i = 0; i < sz; i++) {
            double chance = g_rand_uni();
            // Uses ch from the outer loop to scale probabilities - tripping out here will occur often for farms a long way from the area otherwise
            double calc = cfg_ClosestFarmProbParam2.value()* exp( (cfg_ClosestFarmProbParam1.value() / double( ch ))* farmdists[ i ].m_y );
            if (chance <= calc) {
                // We passed the first test now take a second test based on roost distance
                chance = g_rand_uni();
                // Loop through each roost and find the closest to the farm - then do probability based on that distance.
                double dist = 10000;
                for (int r = 0; r < int( a_roostlist->size() ); r++) {
                    double fdistroostx = farmdists[ i ].m_x - (*a_roostlist)[ r ].m_x;
                    double fdistroosty = farmdists[ i ].m_y - (*a_roostlist)[ r ].m_y;
                    double distf = sqrt( fdistroostx * fdistroostx + fdistroosty * fdistroostx );
                    if (distf < dist) dist = distf;
                }
                calc = -0.01 + pow( dist / 10000.0, cfg_RoostDistProbParam1.value() );
                if (chance>calc) return farmdists[ i ].m_x;
            }
        }
    }
    g_msg->Warn( "FarmManager::FindClosestFarmProbNearRoostBest", "- No suitable farm found" );
    exit( 0 );
}

int FarmManager::FindClosestFarmOpennessProbSmallIsBest	(	HunterInfo	a_hinfo,
		vector< int > *	a_farmlist,
		int	a_openness,
		vector< int > *	a_farmsizelist
	)

Finds the closest farm to this co-ordinate with openness more than a value but uses a probability distribtution for acceptance based on closeness and another based on farm size.

Centroid calculation on farms must be called before calling this method for the first time.
a_farmlist is a pointer to a list of integers with illegal farm ref numbers. The first entry lists the number of illegal numbers. The chance of acceptance is probability based, taking the nearest farm first then testing the next etc.. The probability is based on y = 1*EXP(-x*cfg) with cfg being a fitting parameter in cfg_ClosestFarmProbParam1

We use typedef here to create our own name for APoint - but it is just two unsigned ints. We will use 'x' for the farm num and 'y' for the distance.

We use a vector of AFarmDists to be able to sort it easily

Struct redefining operator < - used for sorting distances from smallest to largest.

Definition at line 2756 of file farm.cpp.

References cfg_ClosestFarmProbParam1, cfg_ClosestFarmProbParam2, cfg_FarmSizeProbParam1, g_msg, g_rand_uni, Farm::GetMaxOpenness(), HunterInfo::homeX, HunterInfo::homeY, CfgFloat::value(), and MapErrorMsg::Warn().

                                                                                                                                                        {
    typedef  APoint AFarmDist;
    vector <AFarmDist> farmdists;
    struct FarmDistSort {
        bool operator()( AFarmDist a, AFarmDist b ) {
            return a.m_y < b.m_y;
        }
    };
    for (unsigned i = 0; i < m_farms.size(); i++) {
        int fnum = m_farms[ i ]->GetFarmNumber();
        if (!InIllegalList( fnum, a_farmlist )) {
            if (m_farms[ i ]->GetMaxOpenness() > a_openness) {
                if (!IsDuplicateRef( fnum, &a_hunterinfo )) {
                    // Is possible to use this farm, so test it.
                    APoint FPt = m_farms[ i ]->GetCentroids();
                    int dist = int(sqrt( (double( FPt.m_x - a_hunterinfo.homeX ) * double( FPt.m_x - a_hunterinfo.homeX ) + double( FPt.m_y - a_hunterinfo.homeY ) * double( FPt.m_y - a_hunterinfo.homeY )) ));
                    if (dist>40000) dist = 40000;
                    AFarmDist fd( unsigned( fnum ), dist );
                    farmdists.push_back( fd );
                }
            }
        }
    }
    // By here we have a list of farms and their distances - now we have the option to sort it or randomise it - one or other line below should be commented out.
    // sort(farmdists.begin(), farmdists.end(), FarmDistSort()); // Sort
    random_shuffle( farmdists.begin(), farmdists.end() ); // Randomise
    // Now the vector is sorted/randomised we loop through and test probabilities
    for (int ch = 1; ch < 100000; ch++) // This loop just makes sure small chances don't mess up the run by tripping out early
    {
        int sz = int( farmdists.size() );
        for (int i = 0; i < sz; i++) {
            double chance = g_rand_uni();
            // Uses ch from the outer loop to scale probabilities - tripping out here will occur often for farms a long way from the area otherwise
            double calc = cfg_ClosestFarmProbParam2.value()* exp( (cfg_ClosestFarmProbParam1.value() / double( ch ))* farmdists[ i ].m_y );
            if (chance <= calc) {
                // We passed the first test now take a second test based on farm size
                chance = g_rand_uni();
                calc = pow( double( (*a_farmsizelist)[ farmdists[ i ].m_x ] / 4000.0 ), cfg_FarmSizeProbParam1.value() );
                if (chance>calc) return farmdists[ i ].m_x;
            }
        }
    }
    g_msg->Warn( "FarmManager::FindClosestFarmProb", "- No suitable farm found" );
    exit( 0 );
}

int FarmManager::FindFarmWithOpenness	(	vector< int > *	a_farmlist,
		int	a_openness
	)

Finds a farm openness more than a value not on the list.

Definition at line 2893 of file farm.cpp.

References g_msg, Farm::GetFarmNumber(), Farm::GetMaxOpenness(), and MapErrorMsg::Warn().

{
    // Centroid calculation on farms must be called before calling this method for the first time
    int sz = (int)m_farms.size();
    int seed = random( sz );
    for (unsigned i = 0; i < m_farms.size(); i++) {
        int index = (i + seed) % sz;
        if (m_farms[ index ]->GetMaxOpenness() > a_openness)
        {
                if (!InIllegalList( m_farms[ index ]->GetFarmNumber(), a_farmlist )) return m_farms[ index ]->GetFarmNumber();
        }
        else AddToIllegalList(m_farms[ index ]->GetFarmNumber(), a_farmlist );
    }
    g_msg->Warn("FarmManager::FindFarmWithOpenness", "- No suitable farm found");
    exit(0);
}

int FarmManager::FindFarmWithRandom

(

vector< int > *

a_farmlist

)

Finds a farm openness more than a value not on the list.

Definition at line 2876 of file farm.cpp.

References g_msg, Farm::GetFarmNumber(), and MapErrorMsg::Warn().

{
    int sz= (int)m_farms.size();
    int f = random(sz);
    while (InIllegalList(m_farms[f]->GetFarmNumber(), a_farmlist))
    {
        f = random(sz);
        if (a_farmlist->size() >= m_farms.size())
        {
            g_msg->Warn("FarmManager::FindFarmWithRandom"," - farm density rule means all hunters cannot be placed");
            exit(0);
        }
    }
    return m_farms[f]->GetFarmNumber();

}

void FarmManager::FindNeighbours

(

)

Finds all OptimisingFarms' neighbours and saves them in the farm's OptimisingFarm::m_neighbours vector.

Definition at line 4180 of file farm.cpp.

References Farm::Centroids(), cfg_Neighbor_dist, OptimisingFarm::Get_almass_no(), OptimisingFarm::GetFarmCentroidX(), OptimisingFarm::GetFarmCentroidY(), Farm::GetType(), OptimisingFarm::Set_Neighbour(), tof_OptimisingFarm, and CfgFloat::value().

                                {
    //determine who is each farm's neighbour and  save them in the farm's vector of its neighbours
    //and print the neighbours

    OptimisingFarm * opf_i;
    OptimisingFarm * opf_k;

    for(int i=0; i<(int)m_farms.size(); i++){
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            opf_i =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            opf_i->Centroids(); //finds each farm's centroid
        }
    }

    for(int i=0; i<(int)m_farms.size(); i++){
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            opf_i =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            int x = opf_i->GetFarmCentroidX();
            int y = opf_i->GetFarmCentroidY();
            int farm_no_i = opf_i->Get_almass_no();

            for(int k = 0; k<(int)m_farms.size(); k++) { //find neighbours of farm i
                if(m_farms[k]->GetType() == tof_OptimisingFarm){ //take only optimising farms
                    opf_k =  dynamic_cast<OptimisingFarm*>(m_farms[k]);
                    int xb = opf_k->GetFarmCentroidX();
                    int yb = opf_k->GetFarmCentroidY();
                    double par = 1000 * cfg_Neighbor_dist.value(); //change km to m
                    int farm_no_k = opf_k->Get_almass_no();

                    if(abs(x - xb) <= par && abs(y - yb) <= par && farm_no_i!=farm_no_k){ //check neighbourship (make sure it is not the same farm)
                        //this is a neighbour
                        opf_i->Set_Neighbour(opf_k); //add farm k to the list of neighbours of farm i
                    }
                }
                else break;
            }
        }
        else break; //break the for loop -there is no more optimising farms
    }

    PrintNeighbours();

}

int FarmManager::FindOpennessFarm

(

int

a_openness

)

Finds a random farm with at least one field with openness above a_openness.

Definition at line 2910 of file farm.cpp.

References Farm::GetFarmNumber(), and Farm::GetMaxOpenness().

{
    int sz = (int) m_farms.size();
    int seed = random(sz);
    for (unsigned i = 0; i < m_farms.size(); i++)
    {
        int index = (i + seed) % sz;
        if (m_farms[index]->GetMaxOpenness() > a_openness) return m_farms[index]->GetFarmNumber();
    }
    return -1; // Should never happen but if it does we need to handle the -1 error code.
}

TTypesOfVegetation FarmManager::Get_crops_summary_BIs_tov ( int  i )

inline

Definition at line 1710 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{return m_crops_summary_BIs[i].Tov;};

double FarmManager::Get_cropTotals ( int  i )

inline

Definition at line 1694 of file farm.h.

{return m_cropTotals[i];};

int FarmManager::Get_cropTotals_size ( )

inline

Definition at line 1697 of file farm.h.

{return (int)m_cropTotals.size();};

int FarmManager::Get_lookup_table ( int  index )

inline

Definition at line 1736 of file farm.h.

Referenced by OptimisingFarm::Make_rotations(), and OptimisingFarm::Match_crop_to_field().

{return m_crop_lookup_table[index];};

double FarmManager::GetDD ( void  )

inline

Returnes day degrees for the period March 1st - November 1st. Used for determining yields of crops that are not harvested.

Definition at line 1692 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{return daydegrees;}; 

int FarmManager::GetFarmArableSize ( int  a_farmref )

inline

Returns the arable area from the farm ref num.

Definition at line 1590 of file farm.h.

    {
        return (GetFarmPtr(a_farmref)->GetArea());
    }

int FarmManager::GetFarmAreaOpenFields ( int  a_farmref, int  a_openness  )

inline

Returns the area of fields with openness more than a_openness.

Definition at line 1617 of file farm.h.

    {
        return (GetFarmPtr(a_farmref)->GetAreaOpenFields(a_openness));
    }

APoint FarmManager::GetFarmCentroid ( int  a_farmref )

inline

Gets the farm centroid as an APoint.

Definition at line 1666 of file farm.h.

References g_msg, and MapErrorMsg::Warn().

    {
        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);
    }

int FarmManager::GetFarmNoFields ( int  a_farmref )

inline

Returns the number of fields owned by a from the farm ref num.

Definition at line 1600 of file farm.h.

    {
        return (GetFarmPtr(a_farmref)->GetNoFields());
    }

int FarmManager::GetFarmNoLookup ( int  a_ref )

inline

Get a farm reference from the lookup table.

Definition at line 1739 of file farm.h.

{ return m_farmmapping_lookup[a_ref * 2]; }

int FarmManager::GetFarmNoOpenFields ( int  a_farmref, int  a_openness  )

inline

Returns the number of fields with openness more than a_openness.

Definition at line 1611 of file farm.h.

    {
        return (GetFarmPtr(a_farmref)->GetNoOpenFields(a_openness));
    }

Farm* FarmManager::GetFarmPtr ( int  a_owner )

inline

Returns the pointer to a farm with a specific number.

Definition at line 1623 of file farm.h.

References g_msg, and MapErrorMsg::Warn().

Referenced by Landscape::SupplyFarmPtr().

                                    {
        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 );
    }

Farm* FarmManager::GetFarmPtrIndex ( int  a_index )

inline

Returns the pointer to a farm with a specific index.

Definition at line 1634 of file farm.h.

                                        {
                return m_farms[ a_index ];
    }

int FarmManager::GetFarmTotalSize ( int  a_farmref )

inline

Returns the total farm area from the farm ref num.

Definition at line 1585 of file farm.h.

    {
        return (GetFarmPtr(a_farmref)->GetTotalArea());
    }

TTypesOfFarm FarmManager::GetFarmType ( int  a_farmref )

inline

Returns the farm type from the farm ref num.

Definition at line 1595 of file farm.h.

    {
        return (GetFarmPtr(a_farmref)->GetType());
    }

int FarmManager::GetFarmTypeLookup ( int  a_ref )

inline

Get a farm type from the lookup table.

Definition at line 1741 of file farm.h.

{ return m_farmmapping_lookup[a_ref * 2 + 1]; }

APoint FarmManager::GetFarmValidCoords ( int  a_farmref )

inline

Returns the number of fields owned by a from the farm ref num.

Definition at line 1605 of file farm.h.

    {
        return (GetFarmPtr(a_farmref)->GetValidCoords());
    }

bool FarmManager::GetIsRenumbered ( )

inline

Returns the flag for renumbering.

Definition at line 1743 of file farm.h.

{ return m_renumbered; }

int FarmManager::GetNoFarms ( )

inline

Definition at line 1757 of file farm.h.

                      {
        return (int)m_farms.size();
    }

int FarmManager::GetRandomFarmRefnum ( )

inline

Returns a random farm reference number.

Definition at line 1638 of file farm.h.

{ return m_farms[random((int)m_farms.size())]->GetFarmNumber(); }

int FarmManager::GetRenumberedFarmRef ( int  a_farmref )

inline

Returns the farm ref index for a farmref.

Definition at line 1745 of file farm.h.

References g_msg, and MapErrorMsg::Warn().

    {
        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 );
    }

double FarmManager::GetSpilledGrain

(

)

Returns the average amount of spilled grain in KJ/m2 this year.

Definition at line 2584 of file farm.cpp.

References g_rand_uni.

{
    /*
    * This data is grain distributions based on 2013 & 2014 data from cereal fields in Jutland
    */
    double graindist2013[26] = {
        29.59, 172.68, 60.59, 39.68, 51.02, 81.63, 268.71, 134.84, 57.40, 30.61, 204.08, 683.67, 108.04,
        141.29, 505.10, 444.61, 293.37, 355.18, 386.90, 381.83, 372.45, 377.55, 320.70, 392.46, 392.86, 435.17
    };
    double graindist2014[28] = {
        109.33, 382.65, 94.19, 765.31, 29.15, 70.15, 1096.94, 436.51, 309.21, 286.28, 480.44, 249.73, 784.10,
        688.78, 2035.45, 920.80, 341.61, 12.24, 113.38, 80.17, 178.57, 480.44, 0.00, 2.83, 1447.12, 1846.94, 1017.86, 477.74
    };
    if (m_SpilledGrain) return graindist2013[ (int)(g_rand_uni() * 28) ];  
    else return graindist2014[ (int)(g_rand_uni() * 26) ];
}

double FarmManager::GetSpilledMaize

(

)

Returns the average amount of spilled maize in KJ/m2 this year.

Definition at line 2601 of file farm.cpp.

References g_rand_uni.

                                    {
    /*
    * This data is maize distributions in kJ/m2 based on 2015 field data from maize fields in Jutland
    */
    double maizedist2015[ 9 ] = {
        102.7905327, 58.19878648, 85.65877728, 110.9055748, 30.65682555, 63.11699379, 59.05947276, 41.9277173, 95.57716202
    };
    return maizedist2015[ (int)(g_rand_uni() * 9) ];
}

bool FarmManager::InIllegalList	(	int	a_farm_ref,
		vector< int > *	a_farmlist
	)

Checks a list to see if a farm matches the illegal list of references.

a_farmlist is a pointer to a list of integers with illegal farm ref numbers. The first entry lists the number of illegal numbers.

Definition at line 2611 of file farm.cpp.

                                                                          {
    unsigned sz = (unsigned) a_farmlist->size();
    for (unsigned f = 0; f < sz; f++) {
        if ((*a_farmlist)[f] == a_farm_ref) return true;
    }
    return false;
}

void FarmManager::InitFarms

(

)

Calls OptimisingFarm::Init for all optimising farms.

Definition at line 2565 of file farm.cpp.

References cfg_OptimisingFarms, Farm::GetType(), OptimisingFarm::Init(), tof_OptimisingFarm, and CfgBool::value().

                           {


if(cfg_OptimisingFarms.value()){
    Create_Output_file_for_farms(); //needed only for the OpitmisingFarms!
}

for(unsigned j=0; j<m_farms.size(); j++){
    if(m_farms[j]->GetType()==tof_OptimisingFarm){
        OptimisingFarm * opf =  dynamic_cast<OptimisingFarm*>(m_farms[j]);
        opf->Init(pm_output_file);
      }
  }

OptimisationOutput(); //03.05 - outputs of the optimisation

}

void FarmManager::InitiateManagement

(

void

)

Definition at line 2284 of file farm.cpp.

{
    for ( unsigned int i = 0; i < m_farms.size(); i++ )
    {
        m_farms[ i ]->InitiateManagement();
    }
}

bool FarmManager::IsDuplicateRef	(	int	a_ref,
		HunterInfo *	a_hinfo
	)

Checks if we already have this ref.

Definition at line 2639 of file farm.cpp.

References HunterInfo::FarmHuntRef.

{
    for (int i = 0; i < int( a_hinfo->FarmHuntRef.size() ); i++)
    {
        
        if (a_ref == a_hinfo->FarmHuntRef[ i ]) return true;
    }
    return false;
}

void FarmManager::OptimisationOutput ( )

protected

Creates output files for all crop level variables and for landscape level crop distribution. Includes results of the initial farm otpimisation.

Definition at line 3974 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, toc_Foobar, tocv_AreaHa, tocv_AreaPercent, tocv_BI, tocv_BIFi, tocv_BIHerb, tocv_Costs, tocv_GM, tocv_Grooming, tocv_Hoeing, tocv_Income, tocv_N, tocv_Nt, tocv_Response, tocv_Savings, tocv_TotalLoss, tocv_Weeding, and CfgBool::value().

                                    {

//1. crop variables
    PrintOutput(tocv_AreaPercent, "AreaPercent.txt");
    PrintOutput(tocv_AreaHa, "AreaHa.txt");
    PrintOutput(tocv_N, "N.txt");
    PrintOutput(tocv_Nt, "Nt.txt");
    PrintOutput(tocv_BIHerb, "BIHerb.txt");
    PrintOutput(tocv_BIFi, "BIFi.txt");
    PrintOutput(tocv_BI, "BI.txt");
    PrintOutput(tocv_Grooming, "Grooming.txt");
    PrintOutput(tocv_Hoeing, "Hoeing.txt");
    PrintOutput(tocv_Weeding, "Weeding.txt");
    PrintOutput(tocv_TotalLoss, "TotalLoss.txt");
    PrintOutput(tocv_Response, "Response.txt");
    PrintOutput(tocv_Income, "Income.txt");
    PrintOutput(tocv_Costs, "Costs.txt");
    PrintOutput(tocv_GM, "GM.txt");
    PrintOutput(tocv_Savings, "Savings.txt");

//2. crop total areas in ha at the landscape level

    CropDistribution(); //now there are total area values for each crop in the m_cropTotals vector
    ofstream ofile("CropDistribution.txt", ios::out);

    if(cfg_OptimiseBedriftsmodelCrops.value()){
        //print crop names (using vector<string>m_cropTypes)
        for(int c=0; c<toc_Foobar; c++) ofile << pm_data->Get_cropTypes_str(c) << '\t';
        ofile  << endl;
        //print the values (total areas in ha)
        for(int c=0; c<toc_Foobar; c++) ofile << m_cropTotals[c] << '\t';
    }
    else{
        //print 'year'
        ofile << "Year" << '\t';
        //print crop names
        for(int c=0; c<pm_data->Get_noCrops(); c++) ofile << pm_data->Get_cropTypes_almass_str(c) << '\t';
        ofile  << endl;
        //it's the first optimisation, so say the year is zero
        ofile << "0" << '\t';
        //print the values (total areas in ha)
        for(int c=0; c<pm_data->Get_noCrops(); c++) ofile << m_cropTotals[c] << '\t';
        ofile << endl;
    }

    //restart the m_cropTotals:
    for(int i=0; i<(int)m_cropTotals.size(); i++){
        m_cropTotals[i]=0;
    }

    ofile.close();
}

void FarmManager::PrintDecModes_counts

(

)

For each OptimizingFarm it prints the number of times each of the decision modes was used within a single simulation. See also OptimisingFarm::m_decision_mode_counters.

Definition at line 4243 of file farm.cpp.

References OptimisingFarm::Get_almass_no(), OptimisingFarm::Get_decision_mode_counters(), Farm::GetType(), and tof_OptimisingFarm.

                                      {

    //create a text file and make headers
    ofstream ofile ("Decision_modes_counts.txt", ios::out);
    ofile << "Farm_no\t" << "imitation\t" <<  "social comparison\t" << "repeat\t"<<  "deliberation\t"<<endl;

    //print each farms no and then the content of the vector ...
    for(int i=0; i<(int)m_farms.size(); i++){
        OptimisingFarm * opf_i;
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            opf_i =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            ofile << opf_i->Get_almass_no() << '\t';
            for(int j=0; j<4; j++){
                ofile << opf_i->Get_decision_mode_counters(j) <<'\t';
            }
            ofile  << endl;
        }
    }

}

void FarmManager::PrintFinalResults

(

)

At the end of a simulation it prints results on crop distribution, pesticide and fertilizer usage.

Definition at line 4264 of file farm.cpp.

References g_date, and Calendar::GetYearNumber().

                                   {

    PrintDecModes_counts();

    int no_years = g_date->GetYearNumber() - 21; //exclude first 9 years + one - the last one, which has just started now - it's Jan 1st//exclude first 20 (0-19) years for the wildlife runs
    double BIherb_sum=0;
    double BIfi_sum=0;
    double BI_sum=0;
    double fertilizer_sum=0;
    double fertilizer_trade_sum=0;

    totalOptFarmsArea *= 0.0001;//change to ha
    totalOptFarmsArea_plant *= 0.0001;
    totalOptFarmsArea_pig *= 0.0001;
    totalOptFarmsArea_cattle *= 0.0001;
    totalOptFarmsArea_other *= 0.0001;

    ofstream ofile ("CropAreasTotal_and_Average.txt", ios::out);
    // "This file  includes summed (over all optimising farms) areas of each crop during the whole simulation, the average areas " ;
    //"(equal to the sum divided by the number of years the simulation was run) and areas as percentage of total optimising farms area.\t" ;
    ofile << "CropName\t" << "Total\t" <<  "Average\t" << "Area_%\t"<< endl;
    for(int i=0; i<(int)m_cropTotals_sum.size(); i++){
        ofile << pm_data->Get_cropTypes_almass_str(i) << '\t';
        ofile << m_cropTotals_sum[i] << '\t';
        ofile << m_cropTotals_sum[i]/no_years << '\t';
        ofile << m_cropTotals_sum[i]/no_years/totalOptFarmsArea * 100 << '%';
        ofile  << endl;
    }
    ofile.close();

    //printing separate files for specific farm types - just areas in %.
    ofstream ofile5 ("CropAreas_plant_farms.txt", ios::out);
    ofile5 << "CropName\t" << "Area_%\t" << endl; //<< "Total\t" <<  "Average\t" <<
    for(int i=0; i<(int)m_cropTotals_plant_sum.size(); i++){
        ofile5 << pm_data->Get_cropTypes_almass_str(i) << '\t';
        ofile5 << m_cropTotals_plant_sum[i]/no_years/totalOptFarmsArea_plant * 100 << '%';
        ofile5  << endl;
    }
    ofile5.close();

    ofstream ofile6 ("CropAreas_pig_farms.txt", ios::out);
    ofile6 << "CropName\t" << "Area_%\t" << endl; //<< "Total\t" <<  "Average\t" <<
    for(int i=0; i<(int)m_cropTotals_pig_sum.size(); i++){
        ofile6 << pm_data->Get_cropTypes_almass_str(i) << '\t';
        ofile6 << m_cropTotals_pig_sum[i]/no_years/totalOptFarmsArea_pig * 100 << '%';
        ofile6  << endl;
    }
    ofile6.close();

    ofstream ofile7 ("CropAreas_cattle_farms.txt", ios::out);
    ofile7 << "CropName\t" << "Area_%\t" << endl; //<< "Total\t" <<  "Average\t" <<
    for(int i=0; i<(int)m_cropTotals_cattle_sum.size(); i++){
        ofile7 << pm_data->Get_cropTypes_almass_str(i) << '\t';
        ofile7 << m_cropTotals_cattle_sum[i]/no_years/totalOptFarmsArea_cattle * 100 << '%';
        ofile7  << endl;
    }
    ofile7.close();

    ofstream ofile8 ("CropAreas_other_farms.txt", ios::out);
    ofile8 << "CropName\t" << "Area_%\t" << endl; //<< "Total\t" <<  "Average\t" <<
    for(int i=0; i<(int)m_cropTotals_other_sum.size(); i++){
        ofile8 << pm_data->Get_cropTypes_almass_str(i) << '\t';
        ofile8 << m_cropTotals_other_sum[i]/no_years/totalOptFarmsArea_other * 100 << '%';
        ofile8  << endl;
    }
    ofile8.close();




    ofstream ofile1 ("PesticideTotals.txt", ios::out);
    ofile1 << "CropName\t" << "BIherb\t" <<  "BIfi\t" << "BI\t" ; //total values within a simulation
    ofile1 << "BIherb_yr\t" <<  "BIfi_yr\t" << "BI_yr\t"; //average values per year (total/no_years)
    ofile1 << "BIherb_ha\t" <<  "BIfi_ha\t" << "BI_ha\t"; //average values per ha (total BI/total area)
    ofile1 << endl;
    for(int i=0; i<(int)m_crops_summary_BIs.size(); i++){
        //ofile1 << m_crops_summary_BIs[i].Tov << '\t';
        ofile1 << pm_data->Get_cropTypes_almass_str(i) << '\t';

        ofile1 << m_crops_summary_BIs[i].BIherb << '\t';
        BIherb_sum += m_crops_summary_BIs[i].BIherb;

        ofile1 << m_crops_summary_BIs[i].BIfi << '\t';
        BIfi_sum += m_crops_summary_BIs[i].BIfi;

        ofile1 << m_crops_summary_BIs[i].BI << '\t';
        BI_sum += m_crops_summary_BIs[i].BI;

        ofile1 << m_crops_summary_BIs[i].BIherb/no_years << '\t';
        ofile1 << m_crops_summary_BIs[i].BIfi/no_years << '\t';
        ofile1 << m_crops_summary_BIs[i].BI/no_years << '\t';
        if(!m_cropTotals_sum[i]==0){
            ofile1 << m_crops_summary_BIs[i].BIherb/m_cropTotals_sum[i] << '\t';
            ofile1 << m_crops_summary_BIs[i].BIfi/m_cropTotals_sum[i] << '\t';
            ofile1 << m_crops_summary_BIs[i].BI/m_cropTotals_sum[i] << '\t';
        }
        else{
            ofile1 <<"0\t" << "0\t" << "0\t" ;
        }
        ofile1  << endl;
    }
    ofile1.close();

    ofstream ofile2 ("FertilizerTotals.txt", ios::out);
    ofile2 << "CropName\t" << "Fertilizer\t" <<  "Fertilizer_yr\t" << "Fertilizer_ha\t"  << endl;
    for(int i=0; i<(int)m_crops_summary_BIs.size(); i++){
        ofile2 << pm_data->Get_cropTypes_almass_str(i) << '\t';
        ofile2 << m_crops_fertilizer[i] << '\t'; //total - all farms, all years
        fertilizer_sum += m_crops_fertilizer[i];
        fertilizer_trade_sum += m_crops_fertilizer_trade[i];
        ofile2 << m_crops_fertilizer[i]/no_years << '\t'; // average per year
        if(m_cropTotals_sum[i]!=0){
            ofile2 << m_crops_fertilizer[i]/m_cropTotals_sum[i] << '\t'; //average per ha
        }
        else{
            ofile2 << "0\t";
        }
        ofile2  << endl;
    }
    ofile2.close();

    //READ the inputs on crop areas in diff model stages
    ifstream ifile("crop_results_stages.txt", ios::in);
    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "crop_results_stages.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    int no_crops = pm_data->Get_noCrops();
    //get rid of the crop names
    for(int c=0; c<no_crops; c++){
        string type;
        ifile>>type;
    }
    for(int stage=0; stage<2; stage++){ //get just the results of the baseline and of the original model
        //stage name
        string stage_name;
        ifile>>stage_name;
        //save crop areas
        for(int a=0; a<no_crops; a++){
            ifile>>m_crop_areas_stages[stage * no_crops + a];
        }
    }

    //determine the sums of squared differences in crop areas (araes as percentages)
    vector<double>sums;
    sums.resize(2);
    for(int s=0; s<2; s++){
        sums[s]=0;
    }
    
    for(int st=0; st<2; st++){
        for(int b=0; b<no_crops; b++){
            double sq_diff =  pow(m_cropTotals_sum[b]/no_years/totalOptFarmsArea * 100 - m_crop_areas_stages[st * no_crops + b]*100, 2);
            sums[st] += sq_diff;
        }
    }

    ofstream ofile3 ("Result_summary.txt", ios::out);
    ofile3 << "BIherb\t" <<  "BIfi\t" << "BI\t" << "Fert\t" << "Fert_trade\t" ;  // sum for all crops/no_years/total_opt_farms_area
    ofile3 << "Sum of sq. diff: Baseline\t" << "Sum of sq. diff: Original\t"; // << "Sum of sq. diff: New opt.\t" << "Sum of sq. diff: Almass_f.area\t" << "Sum of sq. diff: Crop_choice_ev_yr\t";
    //ofile3 << "Sum of sq. diff: Dec.modes\t" << "Sum of sq. diff: Farmer types\t" << "Sum of sq. diff: Types+modes\t" << endl;
    ofile3 << BIherb_sum/totalOptFarmsArea/no_years <<'\t';
    ofile3 << BIfi_sum/totalOptFarmsArea/no_years <<'\t';
    ofile3 << BI_sum/totalOptFarmsArea/no_years <<'\t';
    ofile3 << fertilizer_sum/totalOptFarmsArea/no_years <<'\t';
    ofile3 << fertilizer_trade_sum/totalOptFarmsArea/no_years <<'\t';
    for(int sta=0; sta<2; sta++){
        ofile3 << sums[sta] << '\t';
    }
    ofile3.close();

    //for calibration/sensitivty analysis: comparison to baseline
    ofstream ofile4 ("Output.txt", ios::out);
    //order: 1.BI 2.BI diff%; 3. BI_abs_diff; 4.fert; 5.fert diff%; 6.fert_abs_diff 7.sum of sq. diff. compared to baseline; 8. weigthed measure
    double BIdiff_percent = ((BI_sum/totalOptFarmsArea/no_years/2.2) - 1) *100;//BI in the baseline = 2.2 and is the country level score!
    double BIdiffabs = abs(BIdiff_percent);
    double fert_diff_percent =  ((fertilizer_sum/totalOptFarmsArea/no_years/140.07)-1) * 100;
    double fertdiffabs = abs(fert_diff_percent);
    //ofile4 << endl;
    ofile4 << '\t' << BI_sum/totalOptFarmsArea/no_years <<'\t' << BIdiff_percent << '\t'<< BIdiffabs  <<'\t';
    ofile4 << fertilizer_sum/totalOptFarmsArea/no_years << '\t' << fert_diff_percent << '\t' << fertdiffabs <<'\t'; //fert in baseline = 140.07 kg/ha
    ofile4 << sums[0] << '\t'; 
    ofile4 << 0.2 * abs(BIdiff_percent) + 0.2 * abs(fert_diff_percent) + 0.6 * sums[0] << endl;
    ofile4.close();

    //print also areas of all crops...
    ofstream ofile9 ("Output_crop_areas_percent.txt", ios::out);
    ofile9 << '\t';
    for(int i=0; i<(int)m_cropTotals_sum.size(); i++){
        ofile9 << m_cropTotals_sum[i]/no_years/totalOptFarmsArea * 100 << '\t'; //print just areas (no crop names!)
    }
    ofile9  << endl;
    ofile9.close();


}

void FarmManager::PrintNeighbours ( )

protected

Creates an output file with a list of neighbours of each OptimisingFarm.

Definition at line 4224 of file farm.cpp.

References OptimisingFarm::Get_almass_no(), OptimisingFarm::Get_Neighbour(), OptimisingFarm::Get_NeighboursSize(), Farm::GetType(), and tof_OptimisingFarm.

                                 {
    //create a text file with the farms and their neighbours
    ofstream ofile ("Neighbours.txt", ios::out);
    ofile << "Farm no" << endl;

    //print each farms no and then the numbers of its neighbours
    for(int i=0; i<(int)m_farms.size(); i++){
        OptimisingFarm * opf_i;
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            opf_i =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            ofile << opf_i->Get_almass_no() << '\t';
            for(int j=0; j<opf_i->Get_NeighboursSize(); j++){
                ofile << opf_i->Get_Neighbour(j)->Get_almass_no() <<'\t'; //pointer to the current, i.e. 'i' farm, takes its neighbour (j) and retrieves his almass_no
            }
            ofile  << endl;
        }
    }
}

void FarmManager::PrintOutput ( TTypesOfCropVariables  a_var, string  a_fileName  )

protected

Makes an output file for one crop variable and prints its values for each crop and each OptimisingFarm. Includes results of the initial farm otpimisation.

Definition at line 4027 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, g_msg, OptimisingFarm::Get_almass_no(), OptimisingFarm::Get_crop(), OptimisingFarm::Get_cropsSize(), Farm::GetType(), CropOptimised::m_area_ha, CropOptimised::m_areaPercent, CropOptimised::m_BI, CropOptimised::m_BIFi, CropOptimised::m_BIHerb, CropOptimised::m_costs_ha, CropOptimised::m_GM, CropOptimised::m_grooming, CropOptimised::m_hoeing, CropOptimised::m_income_ha, CropOptimised::m_n, CropOptimised::m_nt, CropOptimised::m_resp, CropOptimised::m_savings, CropOptimised::m_totalLoss, CropOptimised::m_weeding, toc_Foobar, tocv_AreaHa, tocv_AreaPercent, tocv_BI, tocv_BIFi, tocv_BIHerb, tocv_Costs, tocv_GM, tocv_Grooming, tocv_Hoeing, tocv_Income, tocv_N, tocv_Nt, tocv_Response, tocv_Savings, tocv_TotalLoss, tocv_Weeding, tof_OptimisingFarm, CfgBool::value(), MapErrorMsg::Warn(), and WARN_BUG.

                                                                           {

    ofstream ofile (a_fileName.c_str(), ios::out);
    ofile << "Farm no" << '\t';
    //print crop names (using vector<string>m_cropTypes)
    if(cfg_OptimiseBedriftsmodelCrops.value()){
        for(int c=0; c<toc_Foobar; c++) ofile << pm_data->Get_cropTypes_str(c) << '\t';
    }
    else{
        for(int c=0; c<pm_data->Get_noCrops(); c++) ofile << pm_data->Get_cropTypes_almass_str(c) << '\t';
    }
    ofile  << endl;

    for (int i=0; i<(int)m_farms.size(); i++){
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            OptimisingFarm * opf;
            opf =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            int no = opf->Get_almass_no();
            ofile  << no  << '\t';
            int size = opf->Get_cropsSize(); 
            for(int j = 0;  j < size; j++){
                double var_to_print = -1;
                CropOptimised* crop = opf->Get_crop(j);
                switch (a_var){
                        case tocv_AreaPercent:
                            var_to_print = crop ->m_areaPercent;
                            break;
                        case tocv_AreaHa:
                            var_to_print = crop ->m_area_ha;
                            break;
                        case tocv_N:
                            var_to_print = crop ->m_n;
                            break;
                        case tocv_Nt:
                            var_to_print = crop ->m_nt;
                            break;
                        case tocv_BIHerb:
                            var_to_print = crop ->m_BIHerb;
                            break;
                        case tocv_BIFi:
                            var_to_print = crop ->m_BIFi;
                            break;
                        case tocv_BI:
                            var_to_print = crop ->m_BI;
                            break;
                        case tocv_Grooming:
                            var_to_print = crop ->m_grooming;
                            break;
                        case tocv_Hoeing:
                            var_to_print = crop ->m_hoeing;
                            break;
                        case tocv_Weeding:
                            var_to_print = crop ->m_weeding;
                            break;
                        case tocv_TotalLoss:
                            var_to_print = crop ->m_totalLoss;
                            break;
                        case tocv_Response:
                            var_to_print = crop ->m_resp;
                            break;
                        case tocv_Income:
                            var_to_print = crop ->m_income_ha;
                            break;
                        case tocv_Costs:
                            var_to_print = crop ->m_costs_ha;
                            break;
                        case tocv_GM:
                            var_to_print = crop ->m_GM;
                            break;
                        case tocv_Savings:
                            var_to_print = crop ->m_savings;
                            break;
                        default:
                            g_msg->Warn( WARN_BUG, "FarmManager::PrintOutput(): ""Unknown crop variable type! ", "" );
                            exit( 1 );
                }
                ofile  << var_to_print << '\t';
            }
            ofile  << endl;
        }
    }
    ofile.close();
}

void FarmManager::ReadCropsData ( )

protected

Reads the data on crops' parameters that do not vary with farm variables and saves them in a vector DataForOptimisation::m_cropParameters.

Definition at line 3179 of file farm.cpp.

References toc_Foobar, and top_Foobar.

                               {

    //read the input file
    ifstream ifile("crop_parameters.txt", ios::in);
    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "crop_parameters.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get rid of the parameters names
    for(int p=0; p<top_Foobar; p++){
        string type;
        ifile>>type;
    }

    //loop through the crops - save values of the parameters in a vector of the DataForOptimisation class
    for(int c=0; c<toc_Foobar; c++){
        string crop; //in the first column of the input table
        ifile>>crop; //do nothing with it
        for(int p=0; p<top_Foobar; p++){
            double par_value;
            ifile>>par_value;
            int index=top_Foobar*c + p;
            pm_data->Set_cropParameter (par_value, index );
        }
    }
    ifile.close();
}

void FarmManager::ReadCropsData_almass ( )

protected

Reads the data on crops' parameters that do not vary with farm variables and saves them in a vector DataForOptimisation::m_cropParameters. ALMaSS crop mode.

Definition at line 3211 of file farm.cpp.

References top_Foobar.

                                      {

    //read the input file
    ifstream ifile("crop_parameters.txt", ios::in);
    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "crop_parameters.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    int noCrops=0;
    ifile>>noCrops;

    //get rid of the parameters names
    for(int p=0; p<top_Foobar; p++){
        string type;
        ifile>>type;
    }

    //loop through the crops - save values of the parameters in a vector of the DataForOptimisation class
    for(int c=0; c<noCrops; c++){
        string crop; //in the first column of the input table
        ifile>>crop; //do nothing with it
        for(int p=0; p<top_Foobar; p++){
            double par_value;
            ifile>>par_value;
            int index=top_Foobar*(pm_data->Get_cropTypes_almass(c)) + p;  //Get_cropTypes_almass(c) - gives as a tov type crop at position c
            pm_data->Set_cropParameter (par_value, index );
        }
    }
    ifile.close();

}

void FarmManager::ReadCropsData_perFarm_and_Soil ( )

protected

Reads the data on crops' parameters that vary with a farm and soil type (sellingPrice) and saves them in a vector DataForOptimisation::m_sellingPrice.

Definition at line 3526 of file farm.cpp.

References toc_Foobar, toof_Foobar, and tos_Foobar.

                                                {

    //read the input files
    ifstream ifile1("sellingPrice.txt", ios::in);

    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << "sellingPrice.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get rid off the crops names;
    for(int c=0; c<toc_Foobar; c++){
        string type;
        ifile1>>type;
    }

    //loop through the farm and soil types!
    for(int f=0; f<(toof_Foobar * tos_Foobar); f++){
        string farm_type;
        string soil_type;
        ifile1>>farm_type>>soil_type; //get rid off the farm type and soil type names
        for(int c=0; c<toc_Foobar; c++){
            double par_value;
            ifile1>>par_value;
            pm_data->Set_sellingPrice(par_value, toc_Foobar*f + c);
        }
    }
    ifile1.close();
}

void FarmManager::ReadCropsData_perFarm_and_Soil_almass ( )

protected

Reads the data on crops' parameters that vary with a farm and soil type (sellingPrice) and saves them in a vector DataForOptimisation:m_sellingPrice. ALMaSS crop mode.

Definition at line 3559 of file farm.cpp.

References toof_Foobar, tos_Foobar, and tov_Undefined.

                                                       {

     //read the input files
    ifstream ifile1("sellingPrice.txt", ios::in);

    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << "sellingPrice.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    int noCrops=0;
    ifile1>>noCrops;

    //get rid off the crops names;
    for(int c=0; c<noCrops; c++){
        string type;
        ifile1>>type;
    }

    //loop through the farm and soil types!
    for(int f=0; f<(toof_Foobar * tos_Foobar); f++){
        string farm_type;
        string soil_type;
        ifile1>>farm_type>>soil_type; //get rid off the farm type and soil type names
        for(int c=0; c<noCrops; c++){
            double par_value;
            ifile1>>par_value;
            pm_data->Set_sellingPrice(par_value, tov_Undefined*f + pm_data->Get_cropTypes_almass(c));
        }
    }
    ifile1.close();


 }

void FarmManager::ReadCropsData_perFarm_and_Soil_and_Size ( )

protected

Reads the data on crops' parameters that vary with a farm type, soil type and farm size (rotationMax, rotationMin) and saves them in vectors of the DataForOptimisation class.

Definition at line 3597 of file farm.cpp.

References toc_Foobar, tofs_Foobar, toof_Foobar, and tos_Foobar.

                                                         {

    //read the input files
    ifstream ifile1("rotationMax.txt", ios::in);
    ifstream ifile2("rotationMin.txt", ios::in);

    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << "rotationMax.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    } else if(!ifile2.is_open() ){
            cout << "Cannot open input file " << "rotationMin.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get rid off the crops names;
    for(int c=0; c<toc_Foobar; c++){
        string type;
        ifile1>>type;
        ifile2>>type;
    }

    //loop through the farm types, soil types and farm sizes!
    for(int f=0; f<(toof_Foobar *tos_Foobar * tofs_Foobar); f++){
        string farm_type, soil_type, farm_size;
        ifile1>>farm_type>>soil_type>>farm_size; //get rid off the farm type, soil type ad farm size names
        ifile2>>farm_type>>soil_type>>farm_size;
        for(int c=0; c<toc_Foobar; c++){
            double par_value;
            ifile1>>par_value;
            pm_data->Set_rotationMax(par_value, toc_Foobar*f + c);
            ifile2>>par_value;
            pm_data->Set_rotationMin(par_value, toc_Foobar*f + c);
        }
    }
    ifile1.close();
    ifile2.close();
}

void FarmManager::ReadCropsData_perFarm_and_Soil_and_Size_almass ( )

protected

Reads the data on crops' parameters that vary with a farm type, soil type and farm size (rotationMax, rotationMin) and saves them in vectors of the DataForOptimisation class. ALMaSS crop mode.

Definition at line 3640 of file farm.cpp.

References cfg_Areas_Based_on_Distribution, g_msg, tofs_Foobar, toof_Foobar, tos_Foobar, tov_Undefined, CfgBool::value(), MapErrorMsg::Warn(), and WARN_FILE.

                                                                {

    //read the input files

    string rot_max;
    string rot_min;

    if(cfg_Areas_Based_on_Distribution.value()){
        rot_max = "rotationMax_almass.txt";
        rot_min = "rotationMin_almass.txt";
    }
    else{ //rot max and min as specified in the Original Bedriftsmodel
        rot_max = "rotationMax.txt";
        rot_min = "rotationMin.txt";
    }

    ifstream ifile1(rot_max.c_str(), ios::in);
    ifstream ifile2(rot_min.c_str(), ios::in);



    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file with rotation max" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    } else if(!ifile2.is_open() ){
            cout << "Cannot open input file with rotation min" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    int noCrops, noCrops1=0;
    ifile1>>noCrops;
    ifile2>>noCrops1;  //should be always same number!
    if(noCrops!=noCrops1){
        g_msg->Warn( WARN_FILE, "FarmManager::ReadCropsData_perSoilType_almass():"" Numbers of crops differ between input files! ", " " );
        exit( 1 );
    }

    //get rid off the crops names;
    for(int c=0; c<noCrops; c++){
        string type;
        ifile1>>type;
        ifile2>>type;
    }

    //loop through the farm types, soil types and farm sizes!
    for(int f=0; f<(toof_Foobar *tos_Foobar * tofs_Foobar); f++){
        string farm_type, soil_type, farm_size;
        ifile1>>farm_type>>soil_type>>farm_size; //get rid off the farm type, soil type ad farm size names
        ifile2>>farm_type>>soil_type>>farm_size;
        for(int c=0; c<noCrops; c++){
            double par_value;
            ifile1>>par_value;
            pm_data->Set_rotationMax(par_value, tov_Undefined*f + pm_data->Get_cropTypes_almass(c));
            ifile2>>par_value;
            pm_data->Set_rotationMin(par_value, tov_Undefined*f + pm_data->Get_cropTypes_almass(c));
        }
    }
    ifile1.close();
    ifile2.close();

}

void FarmManager::ReadCropsData_perFarmType ( )

protected

Reads the data on crops' parameters that vary with a farm type (fixed, fodder, FUKey) and saves them in vectors of the DataForOptimisation class.

Definition at line 3404 of file farm.cpp.

References toc_Foobar, and toof_Foobar.

                                           {

    //read the input files
    ifstream ifile1("fixed.txt", ios::in);
    ifstream ifile2("fodder.txt", ios::in);
    ifstream ifile3("FUKey.txt", ios::in);

    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << "fixed.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    } else if(!ifile2.is_open() ){
            cout << "Cannot open input file " << "fodder.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    else if(!ifile3.is_open() ){
            cout << "Cannot open input file " << "FUKey.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get rid off the crops names;
    for(int c=0; c<toc_Foobar; c++){
        string type;
        ifile1>>type;
        ifile2>>type;
        ifile3>>type;
    }

    //loop through the farm types!
    for(int f=0; f<toof_Foobar; f++){
        string farm_type;
        ifile1>>farm_type; //get rid off the farm type name
        ifile2>>farm_type;
        ifile3>>farm_type;
        for(int c=0; c<toc_Foobar; c++){
            string par;
            ifile1>>par;
            pm_data->Set_fixed(par, toc_Foobar*f + c);
            ifile2>>par;
            pm_data->Set_fodder(par, toc_Foobar*f + c);
            double par_value;
            ifile3>>par_value;
            pm_data->Set_FUKey(par_value, toc_Foobar*f + c);
        }
    }
    ifile1.close();
    ifile2.close();
    ifile3.close();
}

void FarmManager::ReadCropsData_perFarmType_almass ( )

protected

Reads the data on crops' parameters that vary with a farm type (fixed, fodder, FUKey) and saves them in vectors of the DataForOptimisation class. ALMaSS crop mode.

Definition at line 3460 of file farm.cpp.

References g_msg, toof_Foobar, tov_Undefined, MapErrorMsg::Warn(), and WARN_FILE.

                                                  {

        //read the input files
    ifstream ifile1("fixed.txt", ios::in);
    ifstream ifile2("fodder.txt", ios::in);
    ifstream ifile3("FUKey.txt", ios::in);

    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << "fixed.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    } else if(!ifile2.is_open() ){
            cout << "Cannot open input file " << "fodder.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    else if(!ifile3.is_open() ){
            cout << "Cannot open input file " << "FUKey.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    int noCrops, noCrops1, noCrops2=0;
    ifile1>>noCrops;
    ifile2>>noCrops1;
    ifile3>>noCrops2;  //should be always same number!
    if(noCrops!=noCrops1 || noCrops!=noCrops2){
        g_msg->Warn( WARN_FILE, "FarmManager::ReadCropsData_perSoilType_almass():"" Numbers of crops differ between input files! ", " " );
        exit( 1 );
    }


    //get rid off the crops names;
    for(int c=0; c<noCrops; c++){
        string type;
        ifile1>>type;
        ifile2>>type;
        ifile3>>type;
    }

    //loop through the farm types!
    for(int f=0; f<toof_Foobar; f++){
        string farm_type;
        ifile1>>farm_type; //get rid off the farm type name
        ifile2>>farm_type;
        ifile3>>farm_type;
        for(int c=0; c<noCrops; c++){
            string par;
            ifile1>>par;
            pm_data->Set_fixed(par, tov_Undefined*f + pm_data->Get_cropTypes_almass(c));
            ifile2>>par;
            pm_data->Set_fodder(par, tov_Undefined*f + pm_data->Get_cropTypes_almass(c));
            double par_value;
            ifile3>>par_value;
            pm_data->Set_FUKey(par_value, tov_Undefined*f + pm_data->Get_cropTypes_almass(c));
        }
    }
    ifile1.close();
    ifile2.close();
    ifile3.close();
}

void FarmManager::ReadCropsData_perSoilType ( )

protected

Reads the data on crops' parameters that vary with a soil type (alfa, beta1, beta2, Nnorm) and saves them in vectors of the DataForOptimisation class.

Definition at line 3247 of file farm.cpp.

References toc_Foobar, and tos_Foobar.

                                           {

    //read the input files
    ifstream ifile1("alfa.txt", ios::in);
    ifstream ifile2("beta1.txt", ios::in);
    ifstream ifile3("beta2.txt", ios::in);
    ifstream ifile4("Nnorm.txt", ios::in);
    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << "alfa.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    } else if(!ifile2.is_open() ){
            cout << "Cannot open input file " << "beta1.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    else if(!ifile3.is_open() ){
            cout << "Cannot open input file " << "beta2.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    else if(!ifile4.is_open() ){
            cout << "Cannot open input file " << "Nnorm.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    //get rid off the crops names;
    for(int c=0; c<toc_Foobar; c++){
        string type;
        ifile1>>type;
        ifile2>>type;
        ifile3>>type;
        ifile4>>type;
    }

    //loop through the soil types!
    for(int s=0; s<tos_Foobar; s++){
        string soil;
        ifile1>>soil; //get rid off the soil type name
        ifile2>>soil;
        ifile3>>soil;
        ifile4>>soil;
        for(int c=0; c<toc_Foobar; c++){
            double par_value;
            ifile1>>par_value;
            pm_data->Set_alfa(par_value, toc_Foobar*s + c);
            ifile2>>par_value;
            pm_data->Set_beta1(par_value, toc_Foobar*s + c);
            ifile3>>par_value;
            pm_data->Set_beta2(par_value, toc_Foobar*s + c);
            ifile4>>par_value;
            pm_data->Set_Nnorm(par_value, toc_Foobar*s + c);

        }
    }
    ifile1.close();
    ifile2.close();
    ifile3.close();
    ifile4.close();
}

void FarmManager::ReadCropsData_perSoilType_almass ( )

protected

Reads the data on crops' parameters that vary with a soil type (alfa, beta1, beta2, Nnorm) and saves them in vectors of the DataForOptimisation class. ALMaSS crop mode.

Definition at line 3313 of file farm.cpp.

References g_msg, tos_Foobar, tov_Undefined, MapErrorMsg::Warn(), and WARN_FILE.

                                                  {

    //read the input files
    ifstream ifile1("alfa.txt", ios::in);
    ifstream ifile2("beta1.txt", ios::in);
    ifstream ifile3("beta2.txt", ios::in);
    ifstream ifile4("Nnorm.txt", ios::in);
    ifstream ifile5("biomass_factor_almass.txt", ios::in);

    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << "alfa.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    } else if(!ifile2.is_open() ){
            cout << "Cannot open input file " << "beta1.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    else if(!ifile3.is_open() ){
            cout << "Cannot open input file " << "beta2.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    else if(!ifile4.is_open() ){
            cout << "Cannot open input file " << "Nnorm.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    if (!ifile5.is_open() ) {
            cout << "Cannot open input file " << "biomass_factor_almass.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    int noCrops, noCrops1, noCrops2, noCrops3, noCrops4=0;
    ifile1>>noCrops;
    ifile2>>noCrops1;
    ifile3>>noCrops2;
    ifile4>>noCrops3;
    ifile5>>noCrops4;  //should be always same number!
    if(noCrops!=noCrops1 || noCrops!=noCrops2 || noCrops!=noCrops3 || noCrops!=noCrops4){
        g_msg->Warn( WARN_FILE, "FarmManager::ReadCropsData_perSoilType_almass():"" Numbers of crops differ between input files! ", " " );
        exit( 1 );
    }

    //get rid off the crops names;
    for(int c=0; c<noCrops; c++){
        string type;
        ifile1>>type;
        ifile2>>type;
        ifile3>>type;
        ifile4>>type;
        ifile5>>type;
    }

    //loop through the soil types!
    for(int s=0; s<tos_Foobar; s++){
        string soil;
        ifile1>>soil; //get rid off the soil type name
        ifile2>>soil;
        ifile3>>soil;
        ifile4>>soil;
        ifile5>>soil;
        for(int c=0; c<noCrops; c++){
            double par_value;
            ifile1>>par_value;
            pm_data->Set_alfa(par_value, tov_Undefined*s + pm_data->Get_cropTypes_almass(c)); //Get_cropTypes_almass(c) - gives as a tov type crop at position c
            ifile2>>par_value;
            pm_data->Set_beta1(par_value, tov_Undefined*s + pm_data->Get_cropTypes_almass(c));
            ifile3>>par_value;
            pm_data->Set_beta2(par_value, tov_Undefined*s + pm_data->Get_cropTypes_almass(c));
            ifile4>>par_value;
            pm_data->Set_Nnorm(par_value, tov_Undefined*s + pm_data->Get_cropTypes_almass(c));
            ifile5>>par_value;
            pm_data->Set_biomass_factor(par_value, tov_Undefined*s + pm_data->Get_cropTypes_almass(c));

        }
    }
    ifile1.close();
    ifile2.close();
    ifile3.close();
    ifile4.close();
    ifile5.close();
}

void FarmManager::ReadEnergyMaizePrice ( )

protected

Definition at line 3767 of file farm.cpp.

References l_emaize_price_file, and CfgStr::value().

                                      {


    //read the input files
    ifstream ifile1(l_emaize_price_file.value(), ios::in);

    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << l_emaize_price_file.value() << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }
    //get th enumber of years he file has data for
    int no_years=0;
    ifile1>>no_years;

    //loop
    for(int i=0; i<no_years; i++){
        int year;
        ifile1>>year; //get rid off the year number
        double par_value; 
        ifile1>>par_value;          
        pm_data->Set_emaize_price(par_value);
    }
    ifile1.close();
}

void FarmManager::ReadFarmsData ( )

protected

Reads farm level parameters and saves them in a vector DataForOptimisation::m_farm_data.

Definition at line 3007 of file farm.cpp.

References DataForOptimisation::FarmData::md_almass_no, DataForOptimisation::FarmData::md_farmRealID, DataForOptimisation::FarmData::md_farmSize, DataForOptimisation::FarmData::md_farmType, DataForOptimisation::FarmData::md_soilSubType, and DataForOptimisation::FarmData::md_soilType.

                               {

    int noFarms;
    int noParameters=6; //farm number, farm type, soil type, farm size, real ID, soil subtype

    //read the input file
    ifstream ifile("farms_data.txt", ios::in); //change it later - so that the nme can be set in the config file

    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "farms_data.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get the number of farms
    ifile>>noFarms;
    //get rid off the parameters' names
    string rubbish=""; //put here the names of the parameters;
    for(int i=0; i<noParameters; i++){
        ifile>>rubbish;
    }
    //read the data and assign values to the farm's variables
    for(int f=0; f<noFarms; f++){
        int almass_no, realID, soilSubType;
        string farm_type, soil_type, farm_size;
        ifile >> almass_no >> farm_type >> soil_type >> farm_size >> realID >> soilSubType;
        TTypesOfOptFarms farmType = TranslateFarmCodes (farm_type);
        TTypesOfSoils soilType = TranslateSoilCodes (soil_type);
        TTypesOfFarmSize farmSize = TranslateFarmSizeCodes (farm_size);

        DataForOptimisation::FarmData * fd;
        fd = new DataForOptimisation::FarmData;
        pm_data->m_farm_data.push_back(fd);
        fd->md_almass_no=almass_no;
        fd->md_farmType=farmType;
        fd->md_soilType=soilType;
        fd->md_farmSize=farmSize;
        fd->md_farmRealID=realID;
        fd->md_soilSubType=soilSubType;
     }

    ifile.close();
}

void FarmManager::ReadFarmsData_perFarmType ( )

protected

Reads the data on farms' parameters that vary with a farm type and saves them in a vector of a DataForOptimisation class.

Definition at line 3707 of file farm.cpp.

References toof_Foobar.

                                           {

    //read the input files
    ifstream ifile1("winterMax.txt", ios::in);

    //check if there are all input files
    if ( !ifile1.is_open() ) {
            cout << "Cannot open input file " << "winterMax.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get rid off the parameter name;
        string type;
        ifile1>>type;

    //loop through the farm types!
    for(int f=0; f<toof_Foobar; f++){
        string farm_type;
        ifile1>>farm_type; //get rid off the farm type name
            int par_value;
            ifile1>>par_value;
            pm_data->Set_winterMax(par_value, f);
    }
    ifile1.close();
}

void FarmManager::ReadInitialCropAreas ( )

protected

Reads the data on farms' initial crop distributions and saves them in a vector DataForOptimisation::m_cropAreas.

Definition at line 3094 of file farm.cpp.

References toc_Foobar.

                                      {

    int noFarms;
    //vector<TTypesOfCrops>crops_types; //vector of crops types (enums)

    //read the input file
    ifstream ifile("crop_areas.txt", ios::in);
    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "crop_areas.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get the number of farms /
    ifile>>noFarms;

    //put the names of the crop types to TWO vectors: one with strings, one with enums
    for(int c=0; c<toc_Foobar; c++){
        string type;
        ifile>>type;
        TTypesOfCrops type_enum = TranslateCropsCodes(type);
        pm_data->Set_cropTypes(type_enum);
        pm_data->Set_cropTypes_str(type);
    }

    //loop through the farms; create an instance of each crop type - also when the initial area is zero!
    for(int f=0; f<noFarms; f++){
        double almass_no; //in the first column of the input table
        ifile>>almass_no;
        pm_data->Set_cropArea(almass_no); //put it here so that you can search for the part of a vector - that contains numbers of a given farm
        for(int c=0; c<toc_Foobar; c++){
            double area;
            ifile >> area;
            pm_data->Set_cropArea(area);
        }
    }
    ifile.close();
}

void FarmManager::ReadInitialCropAreas_almass ( )

protected

Reads the data on farms' initial crop distributions and saves them in a vector of a DataForOptimisation class. ALMaSS crop mode.

Definition at line 3135 of file farm.cpp.

                                             {

    int noFarms;
    int noCrops;

    //read the input file
    ifstream ifile("crop_areas.txt", ios::in);
    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "crop_areas.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get the number of crops
    ifile>>noCrops;
    //get the number of farms
    ifile>>noFarms;
    pm_data->Set_noCrops(noCrops);

    //put the names of the crop types to vector with enums and to the vector with strings - will be used for output
    for(int c=0; c<noCrops; c++){
        string type;
        ifile>>type;
        TTypesOfVegetation type_enum = TranslateCropCodes(type);
        pm_data->Set_cropTypes_almass(type_enum);
        pm_data->Set_cropTypes_almass_str(type);
    }

    //loop through the farms; create an instance of each crop type - also when the initial area is zero!
    for(int f=0; f<noFarms; f++){
        double almass_no; //in the first column of the input table
        ifile>>almass_no;
        pm_data->Set_cropArea(almass_no); //put it here so that you can search for the part of a vector - that contains numbers of a given far
        for(int c=0; c<noCrops; c++){
            double area;
            ifile >> area;
            pm_data->Set_cropArea(area);
        }
    }
    ifile.close();
}

void FarmManager::ReadLivestockData ( )

protected

Reads the data on livestock parameters (do not vary with farm variables) and saves them in a vector DataForOptimisation::m_livestockParameters.

Definition at line 3735 of file farm.cpp.

References toa_Foobar, and tolp_Foobar.

                                   {

    //read the input file
    ifstream ifile("livestock_parameters.txt", ios::in);
    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "livestock_parameters.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get rid off the parameter names
    for(int p=0; p<tolp_Foobar; p++){
        string type;
        ifile>>type;
    }

    //loop through the livestock types - save values of the parameters in a vector of the DataForOptimisation class
    for(int l=0; l<toa_Foobar; l++){
        string livestock; //in the first column of the input table
        ifile>>livestock; //do nothing with it
        for(int p=0; p<tolp_Foobar; p++){
            double par_value;
            ifile>>par_value;
            pm_data->Set_livestockParameter(par_value, tolp_Foobar*l + p);
        }
    }
    ifile.close();
}

void FarmManager::ReadLivestockNumbers ( )

protected

Reads the data on livestock numbers and saves them in a vector DataForOptimisation::m_livestockNumbers.

Definition at line 3053 of file farm.cpp.

References toa_Foobar.

                                      {

    int noFarms;
    //vector<TTypesOfAnimals>livestock_types; //vector of livestock types (enums)

    //read the input file
    ifstream ifile("livestock_numbers.txt", ios::in);
    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "livestock_numbers.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get the number of farms //and of types of livestock
    ifile>>noFarms; //>>noLivestockTypes;

    //put the names of the livestock types to the this vector;
    for(int l=0; l<toa_Foobar; l++){
        string type;
        ifile>>type;
        //livestock_types.push_back(TranslateAnimalsCodes(type));
        pm_data->Set_livestockTypes(TranslateAnimalsCodes(type));
    }

    //loop through the farms; create an instance of each livestock type
    for(int f=0; f<noFarms; f++){
        int almass_no; //in the first column of the input table
        ifile>>almass_no;
        pm_data->Set_livestockNumber(almass_no); //put it here so that you can search for the part of a vector - that contains numbers of a given farm
        for(int l=0; l<toa_Foobar; l++){
            int number;
            ifile >> number;
            pm_data->Set_livestockNumber(number);
        }
    }
    ifile.close();

}

void FarmManager::ReadLookupTable ( )

protected

Reads the lookup table with allowed/forbidden crop order from a text file and saves it into a vector m_crop_lookup_table.

Definition at line 4148 of file farm.cpp.

References tov_Undefined.

                                 {

    //read the input file
    ifstream ifile("crops_lookup.txt", ios::in);
    //check if there is an input file
    if ( !ifile.is_open() ) {
            cout << "Cannot open input file " << "crops_lookup.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immedietly
            exit(1);
    }

    //get rid of the crop tov names - first line of the input file
    for(int p=0; p<tov_Undefined+1; p++){
        string tov_type;
        ifile>>tov_type;
    }

    //loop through the crops - save values (-1, 0 or 1) in the vector<int>m_crop_lookup_table;
    for(int r=0; r<tov_Undefined+1; r++){ //rows
        string tov_type; //in the first column of the input table
        ifile>>tov_type; //do nothing with it
        for(int c=0; c<tov_Undefined+1; c++){  //you are at row r, go through all the columns c
            int value;
            ifile >> value;
            m_crop_lookup_table.push_back(value);
        }
    }
    ifile.close();

}

void FarmManager::RemoveField	(	int	a_OwnerIndex,
		LE *	a_field
	)

Definition at line 2298 of file farm.cpp.

{
    m_farms[ a_OwnerIndex ]->RemoveField( a_field );
}

void FarmManager::Save_diff_farm_types_areas

(

)

Calculates and saves total areas of all optimising farms and specific farm types.

Definition at line 2927 of file farm.cpp.

References OptimisingFarm::Get_farmType(), Farm::GetAreaDouble(), Farm::GetType(), tof_OptimisingFarm, toof_Cattle, toof_Other, toof_Pig, and toof_Plant.

                                            {

    //get farms areas and save them
    totalOptFarmsArea=0;
    totalOptFarmsArea_plant=0;
    totalOptFarmsArea_pig=0;
    totalOptFarmsArea_cattle=0;
    totalOptFarmsArea_other=0;
    OptimisingFarm * opf;
    for(int j=0; j<(int)m_farms.size(); j++){
        if(m_farms[j]->GetType() == tof_OptimisingFarm){
            opf =  dynamic_cast<OptimisingFarm*>(m_farms[j]);
            totalOptFarmsArea += opf->GetAreaDouble();
            if(opf->Get_farmType() == toof_Plant){
                totalOptFarmsArea_plant += opf->GetAreaDouble();
            }
            else if(opf->Get_farmType() == toof_Pig){
                totalOptFarmsArea_pig += opf->GetAreaDouble();
            }
            else if(opf->Get_farmType() == toof_Cattle){
                totalOptFarmsArea_cattle += opf->GetAreaDouble();
            }
            else if(opf->Get_farmType() == toof_Other){
                totalOptFarmsArea_other += opf->GetAreaDouble();
            }
        }
    }
}

void FarmManager::Save_last_years_crops_for_farms

(

)

Calls OptimisingFarm::Save_last_years_crops for all optimising farms.

Definition at line 2979 of file farm.cpp.

References Farm::GetType(), OptimisingFarm::Save_last_years_crops(), and tof_OptimisingFarm.

                                                 {

    for(int i=0; i<(int)m_farms.size(); i++){
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            OptimisingFarm * opf;
            opf =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            opf->Save_last_years_crops();
        }
    }
}

void FarmManager::Set_crops_fertilizer ( int  i, double  fert  )

inline

Definition at line 1720 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_crops_fertilizer[i] += fert;};

void FarmManager::Set_crops_fertilizer_trade ( int  i, double  fert_trade  )

inline

Definition at line 1721 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_crops_fertilizer_trade[i] += fert_trade;};

void FarmManager::Set_crops_summary_BIs ( int  i, double  BI  )

inline

Definition at line 1713 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_crops_summary_BIs[i].BI += BI;};

void FarmManager::Set_crops_summary_BIs_fi ( int  i, double  BIfi  )

inline

Definition at line 1712 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_crops_summary_BIs[i].BIfi += BIfi;};

void FarmManager::Set_crops_summary_BIs_herb ( int  i, double  BIherb  )

inline

Definition at line 1711 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_crops_summary_BIs[i].BIherb += BIherb;};

void FarmManager::Set_cropTotals ( int  i, double  value  )

inline

Definition at line 1696 of file farm.h.

{m_cropTotals[i] = value;};

void FarmManager::Set_cropTotals_cattle_sum ( int  i, double  crop_area  )

inline

Definition at line 1717 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_cropTotals_cattle_sum[i] += crop_area;};

void FarmManager::Set_cropTotals_other_sum ( int  i, double  crop_area  )

inline

Definition at line 1718 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_cropTotals_other_sum[i] += crop_area;};

void FarmManager::Set_cropTotals_pig_sum ( int  i, double  crop_area  )

inline

Definition at line 1716 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_cropTotals_pig_sum[i] += crop_area;};

void FarmManager::Set_cropTotals_plant_sum ( int  i, double  crop_area  )

inline

Definition at line 1715 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_cropTotals_plant_sum[i] += crop_area;};

void FarmManager::Set_cropTotals_sum ( int  i, double  crop_area  )

inline

Definition at line 1714 of file farm.h.

Referenced by OptimisingFarm::ActualProfit().

{m_cropTotals_sum[i] += crop_area;};

void FarmManager::SetDD ( double  a_dd )

inline

Definition at line 1693 of file farm.h.

{daydegrees = a_dd;};

void FarmManager::SetSpilledGrain ( bool  a_spilledgrain )

inline

Set m_SpilledGrain which is the flag for either 2013 (true) or 2014 (false) spilled grain distributions.

Definition at line 1685 of file farm.h.

                                                {
        m_SpilledGrain = a_spilledgrain;
    }

void FarmManager::Switch_rotation

(

)

Switches OptimisingFarms Farm::m_rotation to the list of all possible rotational crops.

Definition at line 4465 of file farm.cpp.

References Farm::Assign_rotation(), Farm::GetType(), tof_OptimisingFarm, tov_OrchardCrop, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, and tov_YoungForest.

                                 {

    //1. make a new rotation: include all rotational crops
    vector<TTypesOfVegetation> new_rotation;
    TTypesOfVegetation tov;
    for(int i=0; i<pm_data->Get_cropTypes_almass_size(); i++){
        tov = pm_data->Get_cropTypes_almass(i);
        if (tov!=tov_PermanentGrassGrazed && tov!=tov_PermanentGrassTussocky && tov!=tov_PermanentSetaside &&
            tov!=tov_PermanentGrassLowYield && tov!=tov_YoungForest  && tov!=tov_OrchardCrop) {
                new_rotation.push_back(tov);
        }
    }

    //2. assign it to each farm's m_rotation
    for(int i=0; i<(int)m_farms.size(); i++){
        OptimisingFarm * opf;
        if(m_farms[i]->GetType() == tof_OptimisingFarm){ //take only optimising farms
            opf =  dynamic_cast<OptimisingFarm*>(m_farms[i]);
            opf->Assign_rotation(new_rotation);
        }
    }
}

TTypesOfAnimals FarmManager::TranslateAnimalsCodes

(

string &

str

)

Definition at line 3832 of file farm.cpp.

References g_msg, toa_DCalf, toa_DCow, toa_Deer, toa_Duck, toa_EHen, toa_Finisher, toa_Goat, toa_Goose, toa_Horse, toa_MCalf, toa_MCattle, toa_MDuck, toa_MHen, toa_Mink, toa_Ostrich, toa_Piglet, toa_Sheep, toa_So, toa_Suckler, toa_Turkey, MapErrorMsg::Warn(), and WARN_FILE.

                                                                {
  // This simply checks through the list of legal animal (livestock) types and returns
  // the correct animal type
    string str = astr;
    if ( str == "Horse") return toa_Horse;
    if ( str == "DCow") return toa_DCow;
    if ( str == "Suckler") return toa_Suckler;
    if ( str == "DCalf") return toa_DCalf;
    if ( str == "MCalf") return toa_MCalf;
    if ( str == "MCattle") return toa_MCattle;
    if ( str == "Sheep") return toa_Sheep;
    if ( str == "Goat") return toa_Goat;
    if ( str == "So") return toa_So;
    if ( str == "Finisher") return toa_Finisher;
    if ( str == "Piglet") return toa_Piglet;
    if ( str == "Deer") return toa_Deer;
    if ( str == "Mink") return toa_Mink;
    if ( str == "EHen") return toa_EHen;
    if ( str == "MHen") return toa_MHen;
    if ( str == "Turkey") return toa_Turkey;
    if ( str == "Goose") return toa_Goose;
    if ( str == "Duck") return toa_Duck;
    if ( str == "MDuck") return toa_MDuck;
    if ( str == "Ostrich") return toa_Ostrich;
  // No match so issue a warning and quit
  g_msg->Warn( WARN_FILE, "FarmManager::TranslateAnimalsCodes():"" Unknown Animal type Code ", str.c_str() );
  exit( 1 );
}

TTypesOfVegetation FarmManager::TranslateCropCodes

(

std::string &

str

)

Todo:

Create a OSpringRape crop class and management

Todo:

Create a OSpringWheat crop class and management

Definition at line 1435 of file farm.cpp.

References g_msg, tov_AgroChemIndustryCereal, tov_BroadBeans, tov_Carrots, tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_FieldPeas, tov_FieldPeasSilage, tov_FieldPeasStrigling, tov_FodderBeet, tov_FodderGrass, tov_Maize, tov_MaizeSilage, tov_MaizeStrigling, tov_Oats, tov_OBarleyPeaCloverGrass, tov_OCarrots, tov_OCloverGrassGrazed1, tov_OCloverGrassGrazed2, tov_OCloverGrassSilage1, tov_OFieldPeas, tov_OFieldPeasSilage, tov_OFodderBeet, tov_OGrazingPigs, tov_OMaizeSilage, tov_OOats, tov_OPermanentGrassGrazed, tov_OPotatoes, tov_OrchardCrop, tov_OSBarleySilage, tov_OSeedGrass1, tov_OSeedGrass2, tov_OSpringBarley, tov_OSpringBarleyClover, tov_OSpringBarleyExt, tov_OSpringBarleyGrass, tov_OSpringBarleyPigs, tov_OTriticale, tov_OWinterBarley, tov_OWinterBarleyExt, tov_OWinterRape, tov_OWinterRye, tov_OWinterWheat, tov_OWinterWheatUndersown, tov_OWinterWheatUndersownExt, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_Potatoes, tov_PotatoesIndustry, tov_SeedGrass1, tov_SeedGrass2, tov_Setaside, tov_SpringBarley, tov_SpringBarleyCloverGrass, tov_SpringBarleyCloverGrassStrigling, tov_SpringBarleyGrass, tov_SpringBarleyPeaCloverGrassStrigling, tov_SpringBarleyPTreatment, tov_SpringBarleySeed, tov_SpringBarleySilage, tov_SpringBarleySpr, tov_SpringBarleyStrigling, tov_SpringBarleyStriglingCulm, tov_SpringBarleyStriglingSingle, tov_SpringRape, tov_SpringWheat, tov_SugarBeet, tov_Triticale, tov_WinterBarley, tov_WinterBarleyStrigling, tov_WinterRape, tov_WinterRapeStrigling, tov_WinterRye, tov_WinterRyeStrigling, tov_WinterWheat, tov_WinterWheatShort, tov_WinterWheatStrigling, tov_WinterWheatStriglingCulm, tov_WinterWheatStriglingSingle, tov_WWheatPControl, tov_WWheatPToxicControl, tov_WWheatPTreatment, tov_YoungForest, MapErrorMsg::Warn(), and WARN_FILE.

Referenced by OptimisingFarm::findCropByName_almass(), Farm::ReadRotation(), and UserDefinedFarm::UserDefinedFarm().

                                                                    { //changed to farm manager - was a Farm function, 19.03.13
    // This simply checks through the list of legal crop names and returns
    // the correct tov type

    string str = astr;

    // Unfortunately switch cannot use string so the long way:
    if (str == "SpringBarley") return tov_SpringBarley;
    if (str == "SpringBarleySpr") return tov_SpringBarleySpr;
    if (str == "SpringBarleyPTreatment") return tov_SpringBarleyPTreatment;
    if (str == "WinterBarley") return tov_WinterBarley;
    if (str == "SpringWheat") return tov_SpringWheat;
    if (str == "WinterWheat") return tov_WinterWheat;
    if (str == "WinterRye") return tov_WinterRye;
    if (str == "OrchardCrop") return tov_OrchardCrop;
    if (str == "Oats") return tov_Oats;
    if (str == "OOats") return tov_OOats;
    if (str == "Triticale") return tov_Triticale;
    if (str == "OTriticale") return tov_OTriticale;
    if (str == "Maize") return tov_Maize;
    if (str == "MaizeSilage") return tov_MaizeSilage;
    if (str == "SpringBarleySeed") return tov_SpringBarleySeed;
    if (str == "OSpringRape") return tov_SpringRape; 
    if (str == "SpringRape") return tov_SpringRape;
    if (str == "WinterRape") return tov_WinterRape;
    if (str == "BroadBeans") return tov_BroadBeans;
    if (str == "FieldPeas") return tov_FieldPeas;
    if (str == "FieldPeasSilage") return tov_FieldPeasSilage;
    if (str == "Setaside") return tov_Setaside;
    if (str == "PermanentSetaside") return tov_PermanentSetaside;
    if (str == "SugarBeet") return tov_SugarBeet;
    if (str == "FodderBeet") return tov_FodderBeet;
    if (str == "OFodderBeet") return tov_OFodderBeet;
    if (str == "FodderGrass") return tov_FodderGrass;
    if (str == "CloverGrassGrazed1") return tov_CloverGrassGrazed1;
    if (str == "PotatoesIndustry") return tov_PotatoesIndustry;
    if (str == "Potatoes") return tov_Potatoes;
    if (str == "SeedGrass1") return tov_SeedGrass1;
    if (str == "OWinterBarley") return tov_OWinterBarley;
    if (str == "OWinterBarleyExt") return tov_OWinterBarleyExt;
    if (str == "SpringBarleySilage") return tov_SpringBarleySilage;
    if (str == "OWinterRye") return tov_OWinterRye;
    if (str == "OFieldPeasSilage") return tov_OFieldPeasSilage;
    if (str == "SpringBarleyGrass") return tov_SpringBarleyGrass;
    if (str == "SpringBarleyCloverGrass") return tov_SpringBarleyCloverGrass;
    if (str == "OBarleyPeaCloverGrass") return tov_OBarleyPeaCloverGrass;
    if (str == "OWinterRape") return tov_OWinterRape;
    if (str == "PermanentGrassGrazed") return tov_PermanentGrassGrazed;
    if (str == "PermanentGrassLowYield") return tov_PermanentGrassLowYield;
    if (str == "PermanentGrassTussocky") return tov_PermanentGrassTussocky;
    if (str == "CloverGrassGrazed2") return tov_CloverGrassGrazed2;
    if (str == "SeedGrass2") return tov_SeedGrass2;
    if (str == "OSpringWheat") return tov_OSpringBarley; 
    if (str == "OSpringBarley") return tov_OSpringBarley;
    if (str == "OSpringBarleyExt") return tov_OSpringBarleyExt;
    if (str == "OWinterWheat") return tov_OWinterWheat; 
    if (str == "OWinterWheatUndersown") return tov_OWinterWheatUndersown;
    if (str == "OWinterWheatUndersownExt") return tov_OWinterWheatUndersownExt;
    if (str == "OOats") return tov_OOats;
    if (str == "OFieldPeas") return tov_OFieldPeas;
    if (str == "OCloverGrassGrazed1") return tov_OCloverGrassGrazed1;
    if (str == "OGrazingPigs") return tov_OGrazingPigs;
    if (str == "OCarrots") return tov_OCarrots;
    if (str == "Carrots") return tov_Carrots;
    if (str == "OPotatoes") return tov_OPotatoes;
    if (str == "OSeedGrass1") return tov_OSeedGrass1;
    if (str == "OSpringBarleyGrass") return tov_OSpringBarleyGrass;
    if (str == "OSpringBarleyClover") return tov_OSpringBarleyClover;
    if (str == "OPermanentGrassGrazed") return tov_OPermanentGrassGrazed;
    if (str == "OCloverGrassSilage1") return tov_OCloverGrassSilage1;
    if (str == "OCloverGrassGrazed2") return tov_OCloverGrassGrazed2;
    if (str == "OSeedGrass2") return tov_OSeedGrass2;
    if (str == "WWheatPControl") return tov_WWheatPControl;
    if (str == "WWheatPToxicControl") return tov_WWheatPToxicControl;
    if (str == "WWheatPTreatment") return tov_WWheatPTreatment;
    if (str == "AgroChemIndustryCereal") return tov_AgroChemIndustryCereal;
    if (str == "WinterWheatShort") return tov_WinterWheatShort;
    if (str == "WinterWheatStrigling") return tov_WinterWheatStrigling;
    if (str == "WinterWheatStriglingCulm") return tov_WinterWheatStriglingCulm;
    if (str == "WinterWheatStriglingSgl") return tov_WinterWheatStriglingSingle;
    if (str == "SpringBarleyCloverGrassStrigling") return tov_SpringBarleyCloverGrassStrigling;
    if (str == "SpringBarleyStrigling") return tov_SpringBarleyStrigling;
    if (str == "SpringBarleyStriglingSingle") return tov_SpringBarleyStriglingSingle;
    if (str == "SpringBarleyStriglingCulm") return tov_SpringBarleyStriglingCulm;
    if (str == "MaizeStrigling") return tov_MaizeStrigling;
    if (str == "WinterRapeStrigling") return tov_WinterRapeStrigling;
    if (str == "WinterRyeStrigling") return tov_WinterRyeStrigling;
    if (str == "WinterBarleyStrigling") return tov_WinterBarleyStrigling;
    if (str == "FieldPeasStrigling") return tov_FieldPeasStrigling;
    if (str == "SpringBarleyPeaCloverGrassStrigling") return tov_SpringBarleyPeaCloverGrassStrigling;
    if (str == "YoungForest") return tov_YoungForest;
    if (str == "OMaizeSilage") return tov_OMaizeSilage;
    if (str == "OSpringBarleySilage") return tov_OSBarleySilage;
    if (str == "OSpringBarleyPigs") return tov_OSpringBarleyPigs;

    // No match so issue a warning and quit
    g_msg->Warn( WARN_FILE, "FarmManager::TranslateCropCodes():"" Unknown Crop Code ", str.c_str() );
    exit( 1 );
}

TTypesOfCrops FarmManager::TranslateCropsCodes

(

string &

str

)

Definition at line 3861 of file farm.cpp.

References g_msg, toc_ChrisTree, toc_CloverGrz, toc_EnergyFor, toc_Fruit, toc_FruitTree, toc_GrassClover, toc_GrassEnv1, toc_GrassEnv2, toc_GrassRot, toc_GrassSeed, toc_MaizeSil, toc_Oats, toc_OFodderBeet, toc_OLSeed, toc_OLSeedCut, toc_OOilseed, toc_OSCrops, toc_OSpecCrops, toc_Other, toc_OUncult, toc_Peas, toc_PeasSil, toc_PerGrassLow, toc_PerGrassNorm, toc_Potato, toc_PotatoFood, toc_SBarley, toc_SCerealG, toc_SCerealSil, toc_Setaside, toc_SRape, toc_SugarBeet, toc_Triticale, toc_Uncult, toc_Veg, toc_WBarley, toc_WCerealSil, toc_WRape, toc_WRye, toc_WWheat, MapErrorMsg::Warn(), and WARN_FILE.

Referenced by OptimisingFarm::findCropByName().

                                                           {
// This simply checks through the list of legal crops types and returns
// the correct crop type
    string str = astr;
    if ( str == "SBarley") return toc_SBarley;
    if ( str == "Oats") return toc_Oats;
    if ( str == "OSCrops") return toc_OSCrops;
    if ( str == "WBarley") return toc_WBarley;
    if ( str == "WWheat") return toc_WWheat;
    if ( str == "WRye") return toc_WRye;
    if ( str == "Triticale") return toc_Triticale;
    if ( str == "SRape") return toc_SRape;
    if ( str == "WRape") return toc_WRape;
    if ( str == "OOilseed") return toc_OOilseed;
    if ( str == "Peas") return toc_Peas;
    if ( str == "OLSeed") return toc_OLSeed;
    if ( str == "GrassSeed") return toc_GrassSeed;
    if ( str == "Potato") return toc_Potato;
    if ( str == "PotatoFood") return toc_PotatoFood;
    if ( str == "SugarBeet") return toc_SugarBeet;
    if ( str == "GrassClover") return toc_GrassClover;
    if ( str == "OLSeedCut") return toc_OLSeedCut;
    if ( str == "SCerealSil") return toc_SCerealSil;
    if ( str == "PeasSil") return toc_PeasSil;
    if ( str == "MaizeSil") return toc_MaizeSil;
    if ( str == "WCerealSil") return toc_WCerealSil;
    if ( str == "SCerealG") return toc_SCerealG;
    if ( str == "PerGrassLow") return toc_PerGrassLow;
    if ( str == "PerGrassNorm") return toc_PerGrassNorm;
    if ( str == "GrassEnv1") return toc_GrassEnv1;
    if ( str == "GrassEnv2") return toc_GrassEnv2;
    if ( str == "GrassRot") return toc_GrassRot;
    if ( str == "Setaside") return toc_Setaside;
    if ( str == "Uncult") return toc_Uncult;
    if ( str == "OUncult") return toc_OUncult;
    if ( str == "OFodderBeet") return toc_OFodderBeet;
    if ( str == "CloverGrz") return toc_CloverGrz;
    if ( str == "Veg") return toc_Veg;
    if ( str == "Fruit") return toc_Fruit;
    if ( str == "FruitTree") return toc_FruitTree;
    if ( str == "OSpecCrops") return toc_OSpecCrops;
    if ( str == "ChrisTree") return toc_ChrisTree;
    if ( str == "EnergyFor") return toc_EnergyFor;
    if ( str == "Other") return toc_Other;
    // No match so issue a warning and quit
  g_msg->Warn( WARN_FILE, "FarmManager::TranslateCropCodes():"" Unknown Crop type Code ", str.c_str() );
  exit( 1 );
}

TTypesOfCropVariables FarmManager::TranslateCropVariablesCodes

(

string &

str

)

Definition at line 3949 of file farm.cpp.

References g_msg, tocv_AreaHa, tocv_AreaPercent, tocv_BI, tocv_BIFi, tocv_BIHerb, tocv_Costs, tocv_GM, tocv_Grooming, tocv_Hoeing, tocv_Income, tocv_N, tocv_Nt, tocv_Response, tocv_Savings, tocv_TotalLoss, tocv_Weeding, MapErrorMsg::Warn(), and WARN_FILE.

                                                                           {
  // This simply checks through the list of legal crop variables and returns the correct enum
  string str = astr;
    if ( str == "m_areaPercent" ) return tocv_AreaPercent;
    if ( str == "m_area_ha" ) return tocv_AreaHa;
    if ( str == "m_n" ) return tocv_N;
    if ( str == "m_nt" ) return tocv_Nt;
    if ( str == "m_BIHerb" ) return tocv_BIHerb;
    if ( str == "m_BIFi" ) return tocv_BIFi;
    if ( str == "m_BI" ) return tocv_BI;
    if ( str == "m_grooming" ) return tocv_Grooming;
    if ( str == "m_hoeing" ) return tocv_Hoeing;
    if ( str == "m_weeding" ) return tocv_Weeding;
    if ( str == "m_totalLoss" ) return tocv_TotalLoss;
    if ( str == "m_resp" ) return tocv_Response;
    if ( str == "m_income" ) return tocv_Income;
    if ( str == "m_costs" ) return tocv_Costs;
    if ( str == "m_GM" ) return tocv_GM;
    if ( str == "m_savings" ) return tocv_Savings;

  // No match so issue a warning and quit
  g_msg->Warn( WARN_FILE, "FarmManager::TTypesOfCropVariables():"" Unknown crop variable Code ", str.c_str() );
  exit( 1 );
}

TTypesOfOptFarms FarmManager::TranslateFarmCodes

(

string &

str

)

Definition at line 3796 of file farm.cpp.

References g_msg, toof_Cattle, toof_Other, toof_Pig, toof_Plant, MapErrorMsg::Warn(), and WARN_FILE.

                                                              {
  // This simply checks through the list of legal farm types and returns
  // the correct farm type
  string str = astr;
  if ( str == "Other" ) return toof_Other;
  if ( str == "Cattle" ) return toof_Cattle;
  if ( str == "Plant" ) return toof_Plant;
  if ( str == "Pig" ) return toof_Pig;
  // No match so issue a warning and quit
  g_msg->Warn( WARN_FILE, "FarmManager::TranslateFarmCodes():"" Unknown Farm type Code ", str.c_str() );
  exit( 1 );
}

TTypesOfFarmSize FarmManager::TranslateFarmSizeCodes

(

string &

str

)

Definition at line 3821 of file farm.cpp.

References g_msg, tofs_Business, tofs_Private, MapErrorMsg::Warn(), and WARN_FILE.

                                                                  {
  // This simply checks through the list of legal farm sizes and returns
  // the correct farm size
  string str = astr;
  if ( str == "business" ) return tofs_Business;
  if ( str == "private" ) return tofs_Private;
  // No match so issue a warning and quit
  g_msg->Warn( WARN_FILE, "FarmManager::TranslateFarmSizeCodes():"" Unknown Farm Size Code ", str.c_str() );
  exit( 1 );
}

TTypesOfLivestockParameters FarmManager::TranslateLivestockParametersCodes

(

string &

str

)

Definition at line 3937 of file farm.cpp.

References g_msg, tolp_AUKey, tolp_FUuKey, tolp_Nusable, MapErrorMsg::Warn(), and WARN_FILE.

Referenced by OptimisingFarm::findFodderDemand(), and OptimisingFarm::findTotalNanim().

                                                                                       {
  // This simply checks through the list of legal livestock parameters and returns the correct enum
  string str = astr;
    if ( str == "AUKey" ) return tolp_AUKey;
    if ( str == "Nusable" ) return tolp_Nusable;
    if ( str == "FUuKey" ) return tolp_FUuKey;

  // No match so issue a warning and quit
  g_msg->Warn( WARN_FILE, "FarmManager::TranslateLivestockParametersCodes():"" Unknown Livestock Parameter Code ", str.c_str() );
  exit( 1 );
}

TTypesOfParameters FarmManager::TranslateParametersCodes

(

string &

str

)

Definition at line 3910 of file farm.cpp.

References g_msg, top_AlfaFi, top_AlfaG, top_AlfaH, top_AlfaHerb, top_AlfaW, top_BetaFi, top_BetaG, top_BetaH, top_BetaHerb, top_BetaW, top_PriceFi, top_PriceG, top_PriceH, top_PriceHerb, top_PriceLM, top_PriceW, top_Subsidy, MapErrorMsg::Warn(), and WARN_FILE.

Referenced by OptimisingFarm::crop_parameter().

                                                                     {
  // This simply checks through the list of legal crop parameters (those not varying with farm type etc.)
  //and returns the correct enum
  string str = astr;
    if ( str == "Subsidy" ) return top_Subsidy;
    if ( str == "PriceLM" ) return top_PriceLM;
    if ( str == "PriceHerb" ) return top_PriceHerb;
    if ( str == "PriceFi" ) return top_PriceFi;
    if ( str == "PriceG" ) return top_PriceG;
    if ( str == "PriceH" ) return top_PriceH;
    if ( str == "PriceW" ) return top_PriceW;
    if ( str == "AlfaHerb" ) return top_AlfaHerb;
    if ( str == "BetaHerb" ) return top_BetaHerb;
    if ( str == "AlfaFi" ) return top_AlfaFi;
    if ( str == "BetaFi" ) return top_BetaFi;
    if ( str == "AlfaG" ) return top_AlfaG;
    if ( str == "BetaG" ) return top_BetaG;
    if ( str == "AlfaH" ) return top_AlfaH;
    if ( str == "BetaH" ) return top_BetaH;
    if ( str == "AlfaW" ) return top_AlfaW;
    if ( str == "BetaW" ) return top_BetaW;

  // No match so issue a warning and quit
  g_msg->Warn( WARN_FILE, "FarmManager::TranslateParametersCodes():"" Unknown Parameter Code ", str.c_str() );
  exit( 1 );
}

TTypesOfSoils FarmManager::TranslateSoilCodes

(

string &

str

)

Definition at line 3809 of file farm.cpp.

References g_msg, tos_Clay, tos_Other, tos_Sand, MapErrorMsg::Warn(), and WARN_FILE.

                                                           {
  // This simply checks through the list of legal soil types and returns
  // the correct soil type
  string str = astr;
  if ( str == "Other" ) return tos_Other;
  if ( str == "Sand" ) return tos_Sand;
  if ( str == "Clay" ) return tos_Clay;
  // No match so issue a warning and quit
  g_msg->Warn( WARN_FILE, "FarmManager::TranslateSoilCodes():"" Unknown Soil type Code ", str.c_str() );
  exit( 1 );
}

Member Data Documentation

double FarmManager::daydegrees

protected

Daydegress for period March 1st - November 1st. Used to determine yield of crops that are not harvested (and thus do not have values of biomass at harvest).

Definition at line 1767 of file farm.h.

vector<double> FarmManager::m_crop_areas_stages

protected

Stores information on crop areas calculated in different stages of model development: for comparison in sensitivity analysis.

Definition at line 1814 of file farm.h.

vector<int> FarmManager::m_crop_lookup_table

protected

Specifies which crop order is allowed in a rotation (i.e. if a given crop can follow another crop).

Definition at line 1796 of file farm.h.

vector<double> FarmManager::m_crops_fertilizer

protected

Stores information on aggregate (all farms) fertilizer usage for each crop.

Definition at line 1810 of file farm.h.

vector<double> FarmManager::m_crops_fertilizer_trade

protected

Stores information on aggregate (all farms) fertilizer trade (Nt) usage for each crop.

Definition at line 1812 of file farm.h.

vector<PesticideData> FarmManager::m_crops_summary_BIs

protected

Stores information on aggregate (all farms)pesticide usage for each crop.

Definition at line 1808 of file farm.h.

vector<double> FarmManager::m_cropTotals

protected

Stores crops areas at the landscape level per year.

Definition at line 1794 of file farm.h.

vector<double> FarmManager::m_cropTotals_cattle_sum

protected

Stores the sums of crops areas on cattle farms within one simulation at the landscape level.

Definition at line 1804 of file farm.h.

vector<double> FarmManager::m_cropTotals_other_sum

protected

Stores the sums of crops areas on other farms within one simulation at the landscape level.

Definition at line 1806 of file farm.h.

vector<double> FarmManager::m_cropTotals_pig_sum

protected

Stores the sums of crops areas on pig farms within one simulation at the landscape level.

Definition at line 1802 of file farm.h.

vector<double> FarmManager::m_cropTotals_plant_sum

protected

Stores the sums of crops areas on plant farms within one simulation at the landscape level.

Definition at line 1800 of file farm.h.

vector<double> FarmManager::m_cropTotals_sum

protected

Stores the sums of crops areas within one simulation at the landscape level.

Definition at line 1798 of file farm.h.

int* FarmManager::m_farmmapping_lookup

protected

Used for a dynamic array of lookups converting farm references to internal renumbering.

Definition at line 1772 of file farm.h.

vector<Farm*> FarmManager::m_farms

protected

Definition at line 1763 of file farm.h.

Population_Manager* FarmManager::m_population_manager

protected

Definition at line 1764 of file farm.h.

bool FarmManager::m_renumbered

protected

A flag to show whether renumbering was already done.

Definition at line 1774 of file farm.h.

bool FarmManager::m_SpilledGrain

protected

Is it 2013 (true) or 2014 (false) as far as grain goes.

Definition at line 1769 of file farm.h.

DataForOptimisation* FarmManager::pm_data

Pointer to the DataForOptimisation.

Definition at line 1733 of file farm.h.

Referenced by OptimisingFarm::ActualProfit(), OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation(), OptimisingCattleFarm::checkCattleRotation_almass(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), AnimalFarm::correctFodderDemand(), AnimalFarm::createFodderCrops(), OptimisingFarm::createVariableCrops(), OptimisingFarm::crop_parameter(), AnimalFarm::decreaseCrops(), OptimisingFarm::determineAreas(), AnimalFarm::determineFodderAreas(), AnimalFarm::determineMinFodder(), OptimisingFarm::findFertilizer(), OptimisingFarm::findFodderDemand(), OptimisingFarm::findGrossMargin(), OptimisingFarm::findResponse(), OptimisingFarm::findTotalNanim(), AnimalFarm::increaseCrops(), OptimisingFarm::Initialize(), OptimisingFarm::optimizeCrops(), and OptimisingCattleFarm::setCattleCropsAtMin().

ofstream* FarmManager::pm_output_file

Definition at line 1734 of file farm.h.

double FarmManager::totalOptFarmsArea

protected

Definition at line 1787 of file farm.h.

double FarmManager::totalOptFarmsArea_cattle

protected

Definition at line 1790 of file farm.h.

double FarmManager::totalOptFarmsArea_other

protected

Definition at line 1791 of file farm.h.

double FarmManager::totalOptFarmsArea_pig

protected

Definition at line 1789 of file farm.h.

double FarmManager::totalOptFarmsArea_plant

protected

Definition at line 1788 of file farm.h.

---

The documentation for this class was generated from the following files:

• D:/CJT/Repos/ALMaSS_all/Landscape/farm.h
• D:/CJT/Repos/ALMaSS_all/Landscape/farm.cpp