A farm that carries out crop, pesticide and fertilizer planning using simplified optimisation or other decision startegies. More...

#include <farm.h>

Inheritance diagram for OptimisingFarm:

Classes
struct	CropSort
	Struct used for sorting crops. More...

struct	MakeRotation
	Struct used only in Bedriftsmodel crop type mode for creating m_rotation vector. Bool member used for marking the element of a vector as already assigned a TTypesOfVegetation crop type. More...

struct	reverseSort
	Struct redefining operator < - used for sorting crops. More...

Public Member Functions
	OptimisingFarm (FarmManager *a_myfarmmanager, int a_No)
	The constructor. More...

virtual	~OptimisingFarm ()

TTypesOfOptFarms	Get_farmType (void)

TTypesOfSoils	Get_soilType (void)

TTypesOfFarmSize	Get_farmSize (void)

int	Get_farmRealID (void)

int	Get_soilSubType (void)

int	Get_almass_no (void)

CropOptimised *	Get_crop (int i)

int	Get_cropsSize (void)

void	Set_Livestock (Livestock *p_lvs)

void	Set_Crop (CropOptimised *p_crop)

void	Set_Neighbour (OptimisingFarm *farm)

int	Get_NeighboursSize (void)

OptimisingFarm *	Get_Neighbour (int i)

vector< AlmassCrop >	Get_rotational_crops ()

vector< AlmassCrop >	Get_rotational_crops_visible ()

double	Get_actual_profit ()

double	Get_actual_aggregated_yield ()

int	GetFarmCentroidX ()

int	GetFarmCentroidY ()

void	Set_main_goal (TTypeOfFarmerGoal a_goal)

TTypeOfFarmerGoal	Get_main_goal ()

void	Set_animals_no (int a_number)

int	Get_decision_mode_counters (int index)

bool	Harvest (LE *a_field, double a_user, int a_days)
	OptimisingFarm's virtual version of Farm::Harvest(). Saves information on biomass of a crop at harvest. More...

void	Match_crop_to_field (LE *a_field)
	Finds a crop to be grown on a given field next year. More...

OptimisingFarm *	Find_neighbour_to_imitate ()
	Picks randomly a farmer to imitate/compare with. It chooses among neighbouring farmers with similar farms. More...

void	ActualProfit ()
	Function that determines actual crop yields and profit in a given year. More...

void	Save_last_years_crops ()
	It saves the OptimisingFarm::m_rotational_crops in a vector m_rotational_crops_visible which is accessible for other farmers if they decide to copy it in the following year. More...

void	ChooseDecisionMode ()
	Function determines which decision mode to use. The choice depends on the values of need satisfaction and uncertainty. More...

virtual bool	Spraying_herbicides (TTypesOfVegetation a_tov_type)
	Returns true if a farmer decided to treat a given crop with herbicides. More...

virtual bool	Spraying_fungins (TTypesOfVegetation a_tov_type)
	Returns true if a farmer decided to treat a given crop with fung- and insecticides. More...

virtual double	Prob_multiplier ()
	Used when determining whether there should be a spraying event (i.e. pesticides application) or not. For yield maximizer it increases the chance of spraying event to account for his 'just in case' spraying. More...

void	Init (ofstream *ap_output_file)
	Function carrying out the initial calculations at a farm level (including the initial optimisation). More...

Public Member Functions inherited from Farm
virtual void	Management (void)
	Starts the main management loop for the farm and performs some error checking. More...

void	AddField (LE *a_newfield)
	Adds a field to a farm. More...

void	RemoveField (LE *a_field)
	Removes a field from a farm. More...

	Farm (FarmManager *a_manager)
	Farm constructor - creates an instance of each possible crop type. More...

virtual	~Farm (void)
	Farm destructor - deletes all crop instances and empties event queues. More...

void	SetFarmNumber (int a_farm_num)

int	GetFarmNumber (void)

void	Assign_rotation (vector< TTypesOfVegetation >a_new_rotation)

polylist *	ListOpenFields (int a_openness)
	Returns a list of fields with openness above a_openness. More...

void	Centroids ()
	Finds farm's centroids - x and y. More...

int	GetNoFields ()
	Returns the number of the fields owned. More...

int	GetNoOpenFields (int a_openness)
	Returns the number of the fields above an openness of a_openness. More...

int	GetAreaOpenFields (int a_openness)
	Returns the area of the fields above an openness of a_openness. More...

APoint	GetValidCoords ()
	Returns the valid coordinates of the first field owned by a farm. More...

int	GetMaxOpenness ()
	Returns the maximum openness score of the fields. More...

virtual bool	SleepAllDay (LE *a_field, double a_user, int a_days)
	Nothing to to today on a_field. More...

virtual bool	AutumnPlough (LE *a_field, double a_user, int a_days)
	Carry out a ploughing event in the autumn on a_field. More...

virtual bool	AutumnHarrow (LE *a_field, double a_user, int a_days)
	Carry out a harrow event in the autumn on a_field. More...

virtual bool	AutumnRoll (LE *a_field, double a_user, int a_days)
	Carry out a roll event in the autumn on a_field. More...

virtual bool	AutumnSow (LE *a_field, double a_user, int a_days)
	Carry out a sowing event in the autumn on a_field. More...

virtual bool	WinterPlough (LE *a_field, double a_user, int a_days)
	Carry out a ploughing event in the winter on a_field. More...

virtual bool	DeepPlough (LE *a_field, double a_user, int a_days)
	Carry out a deep ploughing event on a_field. More...

virtual bool	SpringPlough (LE *a_field, double a_user, int a_days)
	Carry out a ploughing event in the spring on a_field. More...

virtual bool	SpringHarrow (LE *a_field, double a_user, int a_days)
	Carry out a harrow event in the spring on a_field. More...

virtual bool	SpringRoll (LE *a_field, double a_user, int a_days)
	Carry out a roll event in the spring on a_field. More...

virtual bool	SpringSow (LE *a_field, double a_user, int a_days)
	Carry out a sowing event in the spring on a_field. More...

virtual bool	GrowthRegulator (LE *a_field, double a_user, int a_days)
	Apply growth regulator to a_field. More...

virtual bool	SynInsecticideTreat (LE *a_field, double a_user, int a_days)
	Apply special insecticide to a_field. More...

virtual bool	ProductApplication0 (LE *a_field, double a_user, int a_days)
	Apply test pesticide to a_field. More...

virtual bool	ProductApplication1 (LE *a_field, double a_user, int a_days)
	Apply test pesticide to a_field. More...

virtual bool	Molluscicide (LE *a_field, double a_user, int a_days)
	Apply molluscidie to a_field. More...

virtual bool	RowCultivation (LE *a_field, double a_user, int a_days)
	Carry out a harrowing between crop rows on a_field. More...

virtual bool	Strigling (LE *a_field, double a_user, int a_days)
	Carry out a mechanical weeding on a_field. More...

virtual bool	StriglingSow (LE *a_field, double a_user, int a_days)
	Carry out a mechanical weeding followed by sowing on a_field. More...

virtual bool	HillingUp (LE *a_field, double a_user, int a_days)
	Do hilling up on a_field, probably of potatoes. More...

virtual bool	Water (LE *a_field, double a_user, int a_days)
	Carry out a watering on a_field. More...

virtual bool	Swathing (LE *a_field, double a_user, int a_days)
	Cut the crop on a_field and leave it lying (probably rape) More...

virtual bool	HarvestLong (LE *a_field, double a_user, int a_days)
	Carry out a harvest on a_field. More...

virtual bool	CattleOut (LE *a_field, double a_user, int a_days)
	Start a grazing event on a_field today. More...

virtual bool	CattleOutLowGrazing (LE *a_field, double a_user, int a_days)
	Start a extensive grazing event on a_field today. More...

virtual bool	CattleIsOut (LE *a_field, double a_user, int a_days, int a_max)
	Generate a 'cattle_out' event for every day the cattle are on a_field. More...

virtual bool	CattleIsOutLow (LE *a_field, double a_user, int a_days, int a_max)
	Generate a 'cattle_out_low' event for every day the cattle are on a_field. More...

virtual bool	PigsOut (LE *a_field, double a_user, int a_days)
	Generate a 'pigs_out' event for every day the cattle are on a_field. More...

virtual bool	PigsAreOut (LE *a_field, double a_user, int a_days)
	Start a pig grazing event on a_field today or soon. More...

virtual bool	PigsAreOutForced (LE *a_field, double a_user, int a_days)
	Start a pig grazing event on a_field today - no exceptions. More...

virtual bool	CutToHay (LE *a_field, double a_user, int a_days)
	Carry out hay cutting on a_field. More...

virtual bool	CutWeeds (LE *a_field, double a_user, int a_days)
	Carry out weed topping on a_field. More...

virtual bool	CutToSilage (LE *a_field, double a_user, int a_days)
	Cut vegetation for silage on a_field. More...

virtual bool	CutOrch (LE *a_field, double a_user, int a_days)
	Cut vegetation on orchard crop. //based on cut to silage - values from cutting function of orchard. More...

virtual bool	StrawChopping (LE *a_field, double a_user, int a_days)
	Carry out straw chopping on a_field. More...

virtual bool	HayTurning (LE *a_field, double a_user, int a_days)
	Carry out hay turning on a_field. More...

virtual bool	HayBailing (LE *a_field, double a_user, int a_days)
	Carry out hay bailing on a_field. More...

virtual bool	BurnStrawStubble (LE *a_field, double a_user, int a_days)
	Burn stubble on a_field. More...

virtual bool	StubbleHarrowing (LE *a_field, double a_user, int a_days)
	Carry out stubble harrowing on a_field. More...

virtual bool	FP_NPKS (LE *a_field, double a_user, int a_days)
	Apply NPKS fertilizer, on a_field owned by an arable farmer. More...

virtual bool	FP_NPK (LE *a_field, double a_user, int a_days)
	Apply NPK fertilizer, on a_field owned by an arable farmer. More...

virtual bool	FP_PK (LE *a_field, double a_user, int a_days)
	Apply PK fertilizer, on a_field owned by an arable farmer. More...

virtual bool	FP_LiquidNH3 (LE *a_field, double a_user, int a_days)
	Apply liquid ammonia fertilizer to a_field owned by an arable farmer. More...

virtual bool	FP_Slurry (LE *a_field, double a_user, int a_days)
	Apply slurry to a_field owned by an arable farmer. More...

virtual bool	FP_ManganeseSulphate (LE *a_field, double a_user, int a_days)
	Apply Manganse Sulphate to a_field owned by an arable farmer. More...

virtual bool	FP_Manure (LE *a_field, double a_user, int a_days)
	Spread manure on a_field owned by an arable farmer. More...

virtual bool	FP_GreenManure (LE *a_field, double a_user, int a_days)
	Spread green manure on a_field owned by an arable farmer. More...

virtual bool	FP_Sludge (LE *a_field, double a_user, int a_days)
	Spread sewege on a_field owned by an arable farmer. More...

virtual bool	FA_NPK (LE *a_field, double a_user, int a_days)
	Apply NPK fertilizer to a_field owned by an stock farmer. More...

virtual bool	FA_PK (LE *a_field, double a_user, int a_days)
	Apply PK fertilizer to a_field owned by an stock farmer. More...

virtual bool	FA_Slurry (LE *a_field, double a_user, int a_days)
	Spready slurry on a_field owned by an stock farmer. More...

virtual bool	FA_AmmoniumSulphate (LE *a_field, double a_user, int a_days)
	Apply ammonium supahte to a_field owned by an stock farmer. More...

virtual bool	FA_Manure (LE *a_field, double a_user, int a_days)
	Spread manure on a_field owned by an stock farmer. More...

virtual bool	FA_GreenManure (LE *a_field, double a_user, int a_days)
	Spread green manure on a_field owned by an stock farmer. More...

virtual bool	FA_Sludge (LE *a_field, double a_user, int a_days)
	Spread sewege sludge on a_field owned by an stock farmer. More...

virtual bool	Trial_PesticideTreat (LE *a_field, double a_user, int a_days)
	Special pesticide trial functionality. More...

virtual bool	Trial_PesticideTreat_DateLimited (LE *a_field, double, int)
	Special pesticide trial functionality. More...

virtual bool	Trial_PesticideTreat_GS (LE *a_field, double a_user, int a_days)
	Special pesticide trial functionality. More...

virtual bool	Trial_ToxicControl (LE *a_field, double a_user, int a_days)
	Special pesticide trial functionality. More...

virtual bool	Trial_Control (LE *a_field, double a_user, int a_days)
	Special pesticide trial functionality. More...

virtual bool	Glyphosate (LE *a_field, double a_user, int a_days)

void	AddNewEvent (TTypesOfVegetation a_event, long a_date, LE *a_field, int a_todo, long a_num, bool a_lock, int a_start, bool a_first_year, TTypesOfVegetation a_crop)
	Adds an event to the event queue for a farm. More...

bool	DoIt (int a_probability)
	Return chance out of 100. More...

TTypesOfFarm	GetType (void)

int	GetArea (void)
	Returns the area of arable fields owned by that farm. More...

int	GetTotalArea (void)
	Returns the area of all fields owned by that farm. More...

double	GetAreaDouble (void)
	Returns the area of arable fields owned by that farm. More...

bool	IsStockFarmer (void)

virtual void	MakeStockFarmer (void)

int	GetIntensity (void)

APoint	GetCentroids ()

TTypesOfVegetation	GetPreviousCrop (int a_index)

TTypesOfVegetation	GetCrop (int a_index)

TTypesOfVegetation	GetNextCrop (int a_index)

void	AddHunter (Hunter *a_hunter)

bool	RemoveHunter (Hunter *a_hunter)

Protected Member Functions
virtual void	InitiateManagement (void)
	Kicks off the farm's management. More...

void	Initialize (FarmManager *a_pfm)
	Assigns to each farm its farm type, farm size, farm's real ID number, and soil type. It creates livestock and crops. More...

virtual void	HandleEvents (void)
	If there are events to carry out do this, and perhaps start a new crop. More...

virtual bool	FungicideTreat (LE *a_field, double, int a_days)
	Carries out fungicide application. Saves information on each application for a given crop. More...

virtual bool	InsecticideTreat (LE *a_field, double, int a_days)
	Carries out insecticide application. Saves information on each application for a given crop. More...

virtual bool	HerbicideTreat (LE *a_field, double, int a_days)
	Carries out herbicide application. Saves information on each application for a given crop. More...

virtual void	createCropsLists (int a_foobar)
	Creates lists of crops. More...

void	createVariableCrops (int a_foobar)
	Creates a list of pointers to all variable crops included in the optimisation and a list of pointers to fixed crops. More...

void	FarmLevelCalculation ()
	Calls functions determining farm level values before the initial optimisation. More...

void	OptimiseFarm (int a_foobar)
	Carries out the whole farm optimisation. More...

void	Check_SG_and_CGG ()
	Modifies areas of SeedGrass1 and SeedGrass2, CloverGrassGrazed1 and CloverGrassGrazed2 to be even. Used only in ALMaSS crops mode (in Bedriftsmodel (original farm optimization model) crops mode this is taken care of in Translate_crops_to_almass()). More...

void	findTotalArea ()
	Determines m_totalArea of a farm. More...

void	findTotalNanim ()
	Determines total animal fertilizer (m_totalNanim) available at a farm. More...

void	findNanim ()
	Determines amount of animal fertilizer per ha (m_Nanim) at a farm. More...

virtual void	findFodderDemand ()
	Determines farm's total demand for fodder (m_totalFUdemand). More...

virtual void	preventCashCrops ()
	Prevents small cattle farms from growing cash crops and maize silage. More...

void	optimizeCrops (int a_foobar)
	Carries out crop optimisation at a farm. More...

void	findFertilizer (CropOptimised *a_crop, int a_foobar, double benefit)
	Determines the optimal amounts of: total fertilizer (CropOptimised::m_n) and purchased fertilizer (CropOptimised::m_nt) for a given crop at a farm. More...

void	findResponse (CropOptimised *a_crop, int a_foobar)
	Determines the response (CropOptimised::m_resp) of a crop at a farm. More...

void	findBIs (CropOptimised *a_crop, double benefit)
	Determines the optimal Treatment frequency indices (behandling index, BI in Danish) (CropOptimised::m_BIHerb, CropOptimised::m_BIFi, CropOptimised::m_BI) for a given crop at a farm. More...

void	fixBI ()
	Sets values of Treatment frequency indices (BI) for crops with fixed amount of pesticides (CropOptimised::m_BIHerb for FodderBeet and both CropOptimised::m_BIHerb and CropOptimised::m_BIFi for PotatoesIndustry and Potatoes). More...

void	findMWeedControl (CropOptimised *a_crop)
	Determines the optimal mechanical weed control means (CropOptimised::m_grooming, CropOptimised::m_hoeing, CropOptimised::m_weeding) for a given crop at a farm. More...

void	findYieldLoss (CropOptimised *a_crop)
	Determines the yield losses (CropOptimised::m_lossHerb, CropOptimised::m_lossFi, CropOptimised::m_totalLoss) for a given crop at a farm. More...

void	findGrossMargin (CropOptimised *a_crop, int a_foobar, double benefit)
	Determines the gross margin (CropOptimised::m_GM) for a given crop at a farm. More...

void	assignFixed ()
	Adds areas of fixed crops to the variable m_assigned. For each fixed crop it saves its area under variable CropOptimised::m_areaPercent. More...

void	sumMinAreas ()
	Adds minimum required areas of variable crops to the variable m_assigned. More...

virtual void	determineAreas (int a_foobar)
	Determines areas of variable crops. More...

void	determineAreas_ha (vector< CropOptimised * >crops)
	Determines areas of crops in ha. More...

virtual void	checkRestrictions ()
	Checks if the restrictions are fulfilled and corrects crops' areas if necessary. More...

virtual void	checkWinterRotation1 ()
	Checks if the restriction on a winter rotation is fulfilled. More...

virtual void	checkWinterCrops ()
	Checks if the restriction on a max. share of winter crops is fulfilled. More...

void	setRotationCropsAtMax ()
	Increases area of winter rotation crops to their max. allowed area. More...

double	crop_parameter (int index, string par_name)
	Reads in crop parameters that do NOT vary with any farm level parameters. More...

CropOptimised *	findCropByName (string crop_name)
	Returns a pointer to a crop whose name is specified as the argument (bedriftsmodel, i.e. original farm optimization model, crops mode). More...

CropOptimised *	findCropByName_almass (string crop_name)
	Returns a pointer to almass crop whose name is specified as the argument (ALMaSS crops mode). More...

CropOptimised *	findCropByName_almass (TTypesOfVegetation a_tov_type)
	Returns a pointer to almass crop whose tov type is specified as the argument. More...

double	total (TTypesOfCropVariables variable_name)
	Function for determining total values per farm after initial optimisation. More...

void	sortCrops (vector< CropSort > &cropsToSort, string sortingKey)
	Sorts structs of type CropSort. More...

void	randomizeCropList (vector< CropSort > &listToRandomize, string key)
	Swaps randomly elements of the list holding same values of the key (according to which the list was previosuly sorted). More...

virtual void	increaseCrops (vector< CropSort >cropsToIncrease, double &howMuchToIncrease)
	Increases area of crops by a specified number. More...

virtual void	decreaseCrops (vector< CropSort >cropsToDecrease, double &howMuchToDecrease)
	Decreases area of a crops by a specified number. More...

void	Print_FarmVariables (ofstream *ap_output_file)
	Prints farm-level variables to a text file (one file for all farms). More...

void	Make_rotations ()
	Creates m_rotation. Not used in ALMaSS crop mode. More...

void	Check_if_area_100 ()
	Checks if the sum of crops' areaPercent is 100%. More...

void	Translate_crops_to_almass ()
	Translates crops from Bedriftsmodel (original farm optimization model) to Almass crops. Used in Bedriftsmodel crop mode. More...

void	Make_almass_crops_vector ()
	Creates a vector storing crops with positive area. Used in ALMaSS crop mode. More...

void	Make_rotational_crops ()
	Creates a vector m_rotational_crops using the results of optimisation. More...

void	Print_rotations (ofstream *ap_output_file)
	Prints the content of a farm's m_rotation. Not used in ALMaSS crop mode. More...

Protected Member Functions inherited from Farm
int	GetFirstDate (TTypesOfVegetation a_tov)
	Gets the start date for a crop type. More...

int	GetNextCropStartDate (LE *a_field, TTypesOfVegetation &a_curr_veg)
	Returns the start date of the next crop in the rotation. More...

virtual int	GetFirstCropIndex (TTypesOfLandscapeElement a_type)
	Gets the first crop for the farm. More...

virtual int	GetNextCropIndex (int a_rot_index)
	Returns the next crop in the rotation. More...

bool	LeSwitch (FarmEvent *ev)
	Call do function for any crop with an outstanding event. Signal if the crop has terminated. More...

void	CheckRotationManagementLoop (FarmEvent *ev)

void	ReadRotation (std::string fname)
	Reads a rotation file into the rotation. More...

void	AssignPermanentCrop (TTypesOfVegetation tov, int pct)
	Used to assign a permanent crop to an otherwise rotational field polygon. More...

int	InvIntPartition (vector< tpct > *items, int target)
	Finds all possible sums of the integers in the items array. More...

Protected Attributes
TTypeOfFarmerGoal	m_main_goal
	Farmer's main goal (determined by a farmer's type) . More...

vector< OptimisingFarm * >	m_neighbours
	Vector of pointers to the farms considered neighbours (fulfilling the neighbourship condition) of a given farm. More...

double	m_need_satisfaction_level
	Farmer's actual satisfaction level. More...

double	m_certainty_level
	Farmer's certainty level. More...

vector< int >	m_decision_mode_counters
	Vector with counters for each decision mode. 0 - imitation, 1 - social comparison, 2 - repeat, 3 - deliberation. More...

double	m_actual_profit
	An actual profit realised at a farm in a given year. More...

double	m_exp_profit
	An expected farm's profit for a given year. More...

double	m_actual_income
	An actual income at a farm in a given year. More...

double	m_exp_income
	An expected farm's income at a farm in a given year. More...

double	m_actual_costs
	Actual costs at a farm in a given year. More...

double	m_exp_costs
	Expected costs at a farm in a given year. More...

double	m_actual_aggregated_yield
	Actual aggregated yield at a farm in a given year. More...

double	m_exp_aggregated_yield
	Expected aggregated yield at a farm in a given year. More...

vector< double >	m_previous_profits
	Vector of profits from previous years. More...

vector< double >	m_previous_incomes
	Vector of incomes from previous years. More...

vector< double >	m_previous_costs
	Vector of costs from previous years. More...

vector< double >	m_previous_aggregated_yields
	Vector of aggregated yields from previous years. More...

vector< double >	m_previous_satisfaction_levels
	Vector of satisfaction levels in five previous years. More...

OptimisingFarm *	m_previously_imitated_neighbour
	The neighbouring farmer whose crops might be copied in imitation and social comparison decision modes. More...

vector< double >	m_animals_numbers
	Vector for storing numbers of animals at a farm in previous years (3). More...

bool	force_deliberation
	If set to true, a farm must use deliberation as a decision strategy. More...

int	animals_no
	Holds the number of animals in a farm at a particular day in a year (depends on a species). More...

vector< Livestock * >	m_livestock
	Vector of pointers to animals belonging to a farm. More...

vector< CropOptimised * >	m_crops
	Vector of pointers to all crops. More...

vector< CropSort >	m_variableCrops
	Vector of structs containing pointers to crops which are not fixed. More...

vector< CropSort >	m_variableCrops2
	Vector of structs containing pointers to crops which are not fixed and: in case of the winter rotation restriction - exclude winter rotation crops, in case of the cattle rotation restriction - exclude the three crops that form the condition of the restriction and winter wheat. More...

vector< CropOptimised * >	m_grownVariableCrops
	Vector of pointers to variable crops that are grown on area larger than areaMin (after determineAreas function was called). More...

vector< CropOptimised * >	m_fixedCrops
	Vector of pointers to fixed crops. More...

vector< CropSort >	m_rotationCrops
	Vector of structs containing pointers to (winter) rotation crops. More...

vector< CropSort >	m_winterCrops
	Vector of structs containing pointers to winter crops. More...

vector< AlmassCrop >	m_crops_almass
	Vector of structs with almass type crops with positive areas in % (result of optimisation). More...

vector< AlmassCrop >	m_rotational_crops
	Vector of structs with almass type crops with positive areas in % (result of optimisation): includes only rotational crops. More...

vector< AlmassCrop >	m_rotational_crops_copy
	A copy of m_rotational_crops used when matching crops to fields. More...

vector< AlmassCrop >	m_rotational_crops_visible
	Stores a copy of m_rotational_crops from a previous year and is accessible to farmers who want to copy this farm's crops (in imitation or social comparison decision mode). More...

TTypesOfOptFarms	m_farmType
	Farm's type (cattle, pig, plant, other). More...

TTypesOfSoils	m_soilType
	Farm's soil type (sandy, clay, other). More...

TTypesOfFarmSize	m_farmSize
	Scale of the farm - business (size above 10 ha) or private (size below 10 ha). More...

int	m_farmRealID
	Farm's real ID number. More...

int	m_soilSubType
	Farm's soil subtype. Defined only for cattle farms on sandy soil (0-bad, 1-good, 2-undefined). More...

int	m_almass_no
	Farm's almass number. More...

double	m_totalArea
	Total area of a farm. A sum of initial crop areas (if in bedriftsmodel, i.e. original farm optimization model, crops mode) or a sum of farm's fields area (if in ALMaSS crops mode). [ha]. More...

double	m_totalArea_original
	Total area of a farm as in bedriftsmodel, i.e. original farm optimization model. [ha]. More...

double	m_area_scaling_factor
	Factor used to scale areas of fixed crops and livestock numbers. Used to adjust these values to the farm's area used in ALMaSS crops mode. More...

double	m_totalNanim
	Total animal fertilizer at a farm. A sum of Livestock::m_NanimUsable (from all types of livestock). [kg]. More...

double	m_Nanim
	Amount of animal fertilizer available at a farm per hectar. [kg/ha]. More...

double	m_totalFUdemandBefore
	Farm's total demand for fodder. [fodder units] More...

double	m_totalFUdemand
	Farm's total demand for fodder (it is covered by growing fodder crops and/or purchasing fodder and thus, at the end of a year it should not be positive). [fodder units] More...

double	m_totalFUt
	Fodder from trade (has to be purchased). [fodder units]. More...

double	m_totalFUgrown
	Fodder grown, i.e. obtained from growing fodder crops. [fodder units]. More...

double	m_assigned
	Variable holding a value of area already reserved for certain crops at a farm. [0-100%]. More...

double	m_totalN
	Total amount of fertilizer used at a farm. [kg]. More...

double	m_totalNt
	Total amount of fertilizer purchased at a farm. [kg]. More...

double	m_totalBIHerb
	Total amount of herbicides which is planned to be applied at a farm. Expressed as a Treatment frequency index (behandling indeks, BI in Danish). More...

double	m_totalBIFi
	Total amount of fung- and insecticides which is planned to be applied at a farm. Expressed as a Treatment frequency index (behandling indeks, BI in Danish). More...

double	m_totalBI
	Total amount of pesticides (sum of m_totalBIHerb and m_totalBIFi) which is planned to be applied at a farm. Expressed as a Treatment frequency index (behandling indeks, BI in Danish). More...

double	m_totalGrooming
	Total grooming planned at a farm. More...

double	m_totalHoeing
	Total hoeing planned at a farm. More...

double	m_totalWeeding
	Total manual weeding planned at a farm. More...

double	m_totalCosts
	Planned total costs of growing crops at a farm. [DKK]. More...

double	m_totalIncome
	Planned total income from growing crops at a farm. [DKK]. More...

double	m_totalProfit
	Planned total profit (= income - costs) at a farm. In case of animal farms costs of purchased fodder is subtracted from the profit. [DKK]. More...

double	m_area_rot
	Area assigned to rotational crops. [ha]. More...

Protected Attributes inherited from Farm
FarmManager *	m_OurManager
	Pointer to the FarmManager. More...

LowPriority< FarmEvent * >	m_queue

vector< LE * >	m_fields

vector< TTypesOfVegetation >	m_rotation

vector< PermCropData >	m_PermCrops

TTypesOfFarm	m_farmtype

HunterList	m_HuntersList
	A list of hunters allocated to this farm. More...

bool	m_stockfarmer

int	m_farm_num

int	m_rotation_sync_index

int	m_intensity

int	m_farm_centroidx
	Farm's centroid, value x. Equal to the average of the x centroid values of all farm's fields. More...

int	m_farm_centroidy
	Farm's centroid, value y. Equal to the average of the y centroid values of all farm's fields. More...

Carrots *	m_carrots

BroadBeans *	m_broadbeans

FodderGrass *	m_foddergrass

CloverGrassGrazed1 *	m_CGG1

CloverGrassGrazed2 *	m_CGG2

FieldPeas *	m_fieldpeas

FieldPeasSilage *	m_fieldpeassilage

Fodderbeet *	m_fodderbeet

Sugarbeet *	m_sugarbeet

OFodderbeet *	m_ofodderbeet

Maize *	m_maize

MaizeSilage *	m_maizesilage

OMaizeSilage *	m_omaizesilage

OBarleyPeaCloverGrass *	m_OBarleyPCG

OCarrots *	m_ocarrots

OCloverGrassGrazed1 *	m_OCGG1

OCloverGrassGrazed2 *	m_OCGG2

OCloverGrassSilage1 *	m_OCGS1

OFieldPeas *	m_ofieldpeas

OFieldPeasSilage *	m_ofieldpeassilage

OFirstYearDanger *	m_ofirstyeardanger

OGrazingPigs *	m_ograzingpigs

OrchardCrop *	m_orchardcrop

Oats *	m_oats

OOats *	m_ooats

OPermanentGrassGrazed *	m_opermgrassgrazed

OPotatoes *	m_opotatoes

OSeedGrass1 *	m_oseedgrass1

OSeedGrass2 *	m_oseedgrass2

OSpringBarley *	m_ospringbarley

OSpringBarleyExt *	m_ospringbarleyext

OSpringBarleyPigs *	m_ospringbarleypigs

OSBarleySilage *	m_osbarleysilage

OTriticale *	m_otriticale

OWinterBarley *	m_owinterbarley

OWinterBarleyExt *	m_owinterbarleyext

OWinterRape *	m_owinterrape

OWinterRye *	m_owinterrye

OWinterWheatUndersown *	m_owinterwheatundersown

OWinterWheat *	m_owinterwheat

OWinterWheatUndersownExt *	m_owinterwheatundersownext

PermanentGrassGrazed *	m_permgrassgrazed

PermanentGrassLowYield *	m_permgrasslowyield

PermanentGrassTussocky *	m_permgrasstussocky

PermanentSetAside *	m_permanentsetaside

Potatoes *	m_potatoes

PotatoesIndustry *	m_potatoesindustry

SeedGrass1 *	m_seedgrass1

SeedGrass2 *	m_seedgrass2

SetAside *	m_setaside

SpringBarley *	m_springbarley

SpringBarleySpr *	m_springbarleyspr

SpringBarleySKManagement *	m_springbarleyskmanagement

SpringBarleyPTreatment *	m_springbarleyptreatment

SpringBarleyCloverGrass *	m_sbarleyclovergrass

SpringBarleySeed *	m_springbarleyseed

SpringBarleySilage *	m_springbarleysilage

SpringRape *	m_springrape

Triticale *	m_triticale

WinterBarley *	m_winterbarley

WinterRape *	m_winterrape

WinterRye *	m_winterrye

WinterWheat *	m_winterwheat

WWheatPControl *	m_wwheatpcontrol

WWheatPToxicControl *	m_wwheatptoxiccontrol

WWheatPTreatment *	m_wwheatptreatment

AgroChemIndustryCereal *	m_agrochemindustrycereal

WinterWheatStrigling *	m_winterwheatstrigling

WinterWheatStriglingCulm *	m_winterwheatstriglingculm

WinterWheatStriglingSingle *	m_winterwheatstriglingsingle

SpringBarleyCloverGrassStrigling *	m_springbarleyclovergrassstrigling

SpringBarleyStrigling *	m_springbarleystrigling

SpringBarleyStriglingCulm *	m_springbarleystriglingculm

SpringBarleyStriglingSingle *	m_springbarleystriglingsingle

MaizeStrigling *	m_maizestrigling

WinterRapeStrigling *	m_winterrapestrigling

WinterRyeStrigling *	m_winterryestrigling

WinterBarleyStrigling *	m_winterbarleystrigling

FieldPeasStrigling *	m_fieldpeasstrigling

SpringBarleyPeaCloverGrassStrigling *	m_springbarleypeaclovergrassstrigling

YoungForestCrop *	m_youngforest

Detailed Description

A farm that carries out crop, pesticide and fertilizer planning using simplified optimisation or other decision startegies.

Definition at line 1885 of file farm.h.

Constructor & Destructor Documentation

OptimisingFarm::OptimisingFarm	(	FarmManager *	a_myfarmmanager,
		int	a_No
	)

The constructor.

Definition at line 4676 of file farm.cpp.

References animals_no, force_deliberation, Initialize(), m_actual_aggregated_yield, m_actual_costs, m_actual_income, m_actual_profit, m_almass_no, m_animals_numbers, m_decision_mode_counters, m_exp_costs, m_exp_income, m_exp_profit, Farm::m_farmtype, m_main_goal, Farm::m_OurManager, m_previously_imitated_neighbour, tof_OptimisingFarm, and tofg_profit.

                                                                      : Farm(a_myfarmmanager)
 {
 
 
     m_farmtype = tof_OptimisingFarm; //this is almass farm type (and not the optimising farm type - see OptimisingFarm::Initialize)
     m_almass_no = a_No; 
     force_deliberation = false; 
     Initialize(m_OurManager);
 
     //assign goals - DEFAULT  values. Later FarmManager assigns main goals again.
     m_main_goal = tofg_profit;
     //m_pest_goal = tofg_profit;
     //m_fert_goal = tofg_profit;
 
     //initialize the actual and expected values
     m_actual_profit=0;
     m_actual_income=0;
     m_actual_costs=0;
     m_actual_aggregated_yield=0;
     m_exp_profit=0;
     m_exp_income=0;
     m_exp_costs=0;
     m_previously_imitated_neighbour = this; 
 
     //initialize the dec. mode counters
     m_decision_mode_counters.resize(4);
     m_decision_mode_counters[0]=0; m_decision_mode_counters[1]=0; m_decision_mode_counters[2]=0; m_decision_mode_counters[3]=0;
 
     m_animals_numbers.resize(0);
     animals_no = 0;
 
 }

virtual OptimisingFarm::~OptimisingFarm ( )

inlinevirtual

Definition at line 1890 of file farm.h.

1890 { ; }

Member Function Documentation

void OptimisingFarm::ActualProfit ( )

Function that determines actual crop yields and profit in a given year.

The function calculates actual yields, income, costs, profits etc. for a given farm in a previous year by accounting for crops grown at its fields. Determines farmer's need satisfaction level (m_need_satisfaction_level) which depends on farmer's actual results relative to the expected ones; the values compared depend on a farmer type, profit maximizer and environmentalist look at profit, yield maximizer looks at aggregated yield. The function also accounts for the pesticide and fertilizer usage in order to obtain aggregate results. The function is used only in ALMaSS crop set mode.

Definition at line 8329 of file farm.cpp.

Referenced by FarmManager::ActualProfit().

                                  { 
     vector<TTypesOfVegetation> veg_type;
     //vector<double>profits; //profit from each field
     //profits.resize(m_fields.size());
 
     double priceNt = cfg_Price_Nt.value(); 
 
     //for energy maize impacts on wildlife
     bool emaize=false;
 
     //exp. agg. yield - for now it is not necessary to do this every year since the fields size is constant, but later it might change!
     m_exp_aggregated_yield = (double)m_fields.size(); //cause each field is expected to give 100% = 1. Except the fields with a crop with exp yield = 0.
 
     //go through all farm's field:
     for(int i=0; i<(int)m_fields.size(); i++){
 
         CropActualValues crop_data;
         TTypesOfVegetation crop;
         double biomass=0; double area=0; double yield_loss_pest=0; double no_herb_app=0; double no_fi_app=0;
         double unit_loss_herb=0; double unit_loss_fi=0; //to determine or take from field's data
         double yield_ha=0; double income_ha=0; double income=0; double costs_ha=0; double costs=0; double profit_ha=0; double profit=0; //to determine
         double yield_exp=0; double yield_ratio=0; double income_exp=0; double costs_exp=0; double profit_exp=0; //to account for - it was already calculated per crop in the determine GM function
         double sellingPrice=0; double priceHerb=0; double priceFi=0; double priceLM=0; double priceH=0; double priceW=0; double priceG=0; double subsidy=0; //economic data - need to be given as input;
         double no_missed_herb_app, no_missed_fi_app = 0; //no_missed - how many applications of herb/fi were missed
         double fert_applied=0; double fert_opt=0; double fert_trade=0; double beta1=0; double beta2=0; double alfaH=0; double alfaFI=0;
         double yield_factor = 0; //this serves both as biomass-to-yield factor and day degrees-to-yield factor - they are saved in one input table (a single crop has just one of these factors!)
         VegElement * pf =  dynamic_cast<VegElement*>(m_fields[i]);
 
         int cropDataStorage_index=-1; //initialize
 
         if(pf->Get_taken(1)){ //there is a crop at position one - so account for this crop; otherwise go to position 0
             crop_data = pf->Get_CropDataStorage(1);
             cropDataStorage_index = 1;
         }
         else{
             crop_data = pf->Get_CropDataStorage(0);
             cropDataStorage_index = 0;
             if(crop_data.taken==false){//error
                 g_msg->Warn( WARN_BUG, "OptimisingFarm::ActualProfit(): There is no crop data in the fields m_CropDataStorage", "" );
                 exit( 1 );
             }
         }
 
         crop = crop_data.tov_type;
 
         //for energy maize impacts on wildlife
         if (crop==tov_Maize) emaize = true;
         //
 
         bool do_accounting = true;
         if(cropDataStorage_index==0){ //could be this crop was not harvested yet
             bool harvested = crop_data.harvested;
             if(crop!= tov_PotatoesIndustry && crop!=tov_Potatoes && crop!=tov_CloverGrassGrazed1 && crop!=tov_CloverGrassGrazed2 && crop!= tov_SpringBarleySilage && crop!=tov_PermanentGrassLowYield
                 && crop!=tov_PermanentGrassGrazed && crop!=tov_PermanentGrassTussocky && crop!=tov_YoungForest && crop!=tov_OrchardCrop && crop!=tov_FodderGrass
                 && !harvested){
                 //this is a crop that shoud be harvested, but so far it wasn't - so do not account for this crop yet! - just skip this field in accounting
                 do_accounting = false;
             }
         }
 
         if(do_accounting){
             area = crop_data.area * 0.0001; //change the units from sq. meters to ha!
 
             if(crop==tov_SeedGrass1 || crop==tov_SeedGrass2){ //alfaherb is more than 100! - so problem with negative yield
                 double betaH = crop_parameter(crop, "BetaHerb");
                 alfaFI = crop_parameter(crop, "AlfaFi");
                 unit_loss_herb = betaH/100/2;
                 unit_loss_fi = alfaFI/100;
             }
             else{
                 alfaH = crop_parameter(crop, "AlfaHerb");
                 alfaFI = crop_parameter(crop, "AlfaFi");
                 unit_loss_herb = alfaH/100; //yield loss per unit of herb application, = max yield loss/optBI = betaH/optBI = alfa. (and /100).
                 unit_loss_fi = alfaFI/100; //yield loss per unit of fung-insecticide application
             }
 
             //draw random numbers to modify the pest related yield loss
             //method from: http://stackoverflow.com/questions/9651024/using-stdtr1normal-distribution-in-qt
             std::random_device rd;
             std::normal_distribution<double> dist(1, 0.2);
             std::mt19937 engine(rd());
             double r_number_1 = dist(engine);
             double r_number_2 = dist(engine);
 
 
             //determine the pest related yield loss
             no_missed_herb_app = crop_data.missed_herb_app;
             no_missed_fi_app = crop_data.missed_fi_app;
             yield_loss_pest = no_missed_herb_app * unit_loss_herb * r_number_1 + no_missed_fi_app * unit_loss_fi * r_number_2; //total yield loss due to missed pesticide applications
 
             //determine the yield
             biomass = crop_data.biomass_at_harvest;
             yield_factor = m_OurManager->pm_data->Get_biomass_factor(tov_Undefined * m_soilType + crop); //crop is tov - integer
 
             fert_applied = findCropByName_almass (crop)->m_n;
             fert_opt = findCropByName_almass (crop)->m_optimalN;
             fert_trade = findCropByName_almass (crop)->m_nt;
 
             int index = tov_Undefined * m_soilType + crop;
             beta1=m_OurManager->pm_data->Get_beta1(index);
             beta2=m_OurManager->pm_data->Get_beta2(index);
 
             double dd=m_OurManager->GetDD();
 
             yield_ha = (biomass==-1)? dd : biomass; //if biomass=-1 this crop is not harvested - use daydegress to estimate the yield
             yield_ha *= yield_factor; //multiply by the factor to convert biomass to yield - works both for harvested and not harvested crops.
             if(fert_opt!=0){
                 yield_ha -= (1 - fert_applied/fert_opt) * (beta1 * fert_opt + beta2 * fert_opt*fert_opt); //subtract the amount which depends on the applied ferilizer - if the applied=optimal, then amount subtracted=0. The expression in brackets - with betas - corresponds to the max yield loss-when fert=0.
             }
             yield_ha *= (1-yield_loss_pest); //finally account for the yield loss due to pests
 
             //get other numbers for economic calculations
             sellingPrice = m_OurManager->pm_data->Get_sellingPrice(tov_Undefined*tos_Foobar*m_farmType + tov_Undefined*m_soilType + crop); //always tov_Undefined because this funtion is called ONLY  in almass crop mode!
             priceFi = crop_parameter(crop, "PriceFi");
             priceHerb = crop_parameter(crop, "PriceHerb");
             priceG = crop_parameter(crop, "PriceG");
             priceH = crop_parameter(crop, "PriceH");
             priceW = crop_parameter(crop, "PriceW");
             priceLM = crop_parameter(crop, "PriceLM");
             subsidy =crop_parameter(crop, "Subsidy");
 
             double grooming = findCropByName_almass (crop)->m_grooming;
             double hoeing = findCropByName_almass (crop)->m_hoeing;
             double weeding = findCropByName_almass (crop)->m_weeding;
 
             no_herb_app = crop_data.no_herb_app;
             no_fi_app = crop_data.no_fi_app;
 
             //special case for potatoes and fodder beet
             if(crop==tov_Potatoes || crop==tov_PotatoesIndustry){
                 no_herb_app = 1.41; //need to be consistent with numbers in the fix BI function!
                 no_fi_app = 9.28;
             }
             if(crop==tov_FodderBeet){
                 no_herb_app = 2.28; //need to be consistent with numbers in the fix BI function!
             }
 
             //saving the amount of pesticides and fertilizer
             if(g_date->GetYearNumber()>9){ //do it for the first time in year 10 ->only then we account for new dec.- modes
                 for(int i=0; i<m_OurManager->pm_data->Get_noCrops(); i++){
                     if(m_OurManager->Get_crops_summary_BIs_tov(i) == crop){
                         m_OurManager->Set_crops_summary_BIs_herb(i, no_herb_app * area);
                         m_OurManager->Set_crops_summary_BIs_fi(i, no_fi_app * area);
                         m_OurManager->Set_crops_summary_BIs(i, (no_fi_app+no_herb_app) * area);
                         m_OurManager->Set_crops_fertilizer(i, fert_applied * area);
                         m_OurManager->Set_crops_fertilizer_trade(i, fert_trade * area);
                         break;
                     }
                 }
             }
 
 
         //GET THE ACTUAL FIGURES:
             //1. determine the actual income from this crop: use selling price also for fodder crops! they do not add to income, just diminish the costs of fodder...hm
             income_ha = yield_ha * sellingPrice + subsidy;
             income = income_ha * area; //total income from this crop
 
             //2. account for the costs incurred for this crop
             costs_ha = no_herb_app*priceHerb + no_fi_app*priceFi + grooming*priceG + hoeing*priceH + weeding*priceW + fert_trade*priceNt+ priceLM;
             costs = costs_ha * area;
 
             //3. determine the actual profit
             profit_ha = income_ha - costs_ha;
             profit = profit_ha * area;
 
             //4. determine what part of the expected yield you actually got from this crop - but do this by ha! here there are only crops that were grown this year - because we go through the list of fields
             yield_exp = findCropByName_almass (crop)->m_resp;
             if(yield_exp!=0){
                 yield_ratio = yield_ha/yield_exp; // must be min. 0, can be > than 1.
             }
             else{
                 m_exp_aggregated_yield -=1; //this crop wasn't expected to yield anything, so exclude it from the sum of expected yields
             }
 
         //add actual figures for this crop to the totals at a farm this year
             m_actual_income += income;
             m_actual_costs += costs;
             m_actual_profit += profit;
             m_actual_aggregated_yield += yield_ratio;
 
 
         //add expected figures for this crop to the totals at a farm  this year
             //get the expected values! use the actual area - otherwise a comparison doesn't make sense!
 
             //to determine the expected income use last year's price
             double resp = findCropByName_almass (crop)->m_resp;
             double totalLoss = findCropByName_almass (crop)->m_totalLoss;
             double sellingPrice_lastyr = m_OurManager->pm_data->Get_sellingPrice_lastyr(tov_Undefined*tos_Foobar*m_farmType + tov_Undefined*m_soilType + crop); //always tov_Undefined because this funtion is called ONLY  in almass crop mode!
 
             int index1 = tov_Undefined * m_farmType + findCropByName_almass (crop)->m_cropType_almass;
             bool fodder = m_OurManager->pm_data->Get_fodder(index1);
             if (fodder) income_exp = subsidy;
             else income_exp = (sellingPrice_lastyr*resp*(1-totalLoss/100)+subsidy)*area;
 
             costs_exp = findCropByName_almass (crop)->m_costs_ha *area;
             profit_exp = income_exp - costs_exp; 
 
             m_exp_income += income_exp; //add income expected from this crop to the total expected income
             m_exp_costs += costs_exp;
             m_exp_profit += profit_exp;
 
             //clean data in this field's struct: remove the data that you just accounted for
             pf->Clean_CropDataStorage(cropDataStorage_index);
         }
         else{//there was no accounting done, print the crop and year in which this happened
             #ifdef _DEBUG
             g_msg->Warn("OptimisingFarm::ActualProfit(): There was no accounting for tov: ", crop);
             //g_msg->Warn("Farm Number: ",GetFarmNumber());
             g_msg->Warn("Year Number: ",g_date->GetYearNumber());
             #endif
         }
 
     //send the info on this field's crop for the landscape total crop areas accounting
         //first find the right index in m_cropTotals:
         int index_for_croptotals=0;
         int size = m_OurManager->pm_data->Get_cropTypes_almass_size();
         for(int k = 0; k<size; k++){
             TTypesOfVegetation crop_type = m_OurManager->pm_data->Get_cropTypes_almass(k);
             if(crop_type == crop){
                 index_for_croptotals = k;
                 break;
             }
         }
         //then add the area of this field to the right element of m_cropTotals; change the units from sq meters to ha.
         m_OurManager->Add_to_cropTotals(index_for_croptotals, m_fields[i]->GetArea() * 0.0001); //yearly totals
         if(g_date->GetYearNumber()>20){ //do it for the first time in year 10 ->only then we account for new dec.- modes//for wildlife runs - only since year 20 when emaize appears, but here in year 20 we only account for year 19...that's why it has to be '>20'
             m_OurManager->Set_cropTotals_sum(index_for_croptotals, m_fields[i]->GetArea() * 0.0001);
             if(m_farmType == toof_Plant){
                 m_OurManager->Set_cropTotals_plant_sum(index_for_croptotals, m_fields[i]->GetArea() * 0.0001);
             }
             else if(m_farmType == toof_Pig){
                 m_OurManager->Set_cropTotals_pig_sum(index_for_croptotals, m_fields[i]->GetArea() * 0.0001);
             }
             else if(m_farmType == toof_Cattle){
                 m_OurManager->Set_cropTotals_cattle_sum(index_for_croptotals, m_fields[i]->GetArea() * 0.0001);
             }
             else if(m_farmType == toof_Other){
                 m_OurManager->Set_cropTotals_other_sum(index_for_croptotals, m_fields[i]->GetArea() * 0.0001);
             }
         }
 
         //then add also to farm type specific crop totals
 
 
 
     }//for: going through m_fields
 
 
     //print the expected and actual values
     ofstream ofile ("Economic_figures.txt", ios::app);
     ofile << "farm_no: " << m_almass_no << '\t' << "year_no " << g_date->GetYearNumber() << endl;
     ofile << "Expected: " << '\t' <<"Income " << m_exp_income << "\tCosts "<< m_exp_costs << "\tProfit " << m_exp_profit<< "\tAgg.yield " << m_exp_aggregated_yield;
     ofile << endl;
     ofile << "Actual: " << '\t' << "Income " << m_actual_income << "\tCosts "<< m_actual_costs << "\tProfit " << m_actual_profit<< "\tAgg.yield " << m_actual_aggregated_yield;
     ofile << endl <<endl;
     ofile.close();
 
 
     //save the economic figures for this year (or rather past - we account for things happen in the year before the current March 1st, xxxx)
     m_previous_profits.push_back(m_actual_profit);
     m_previous_incomes.push_back(m_actual_income);
     m_previous_costs.push_back(m_actual_costs);
     m_previous_aggregated_yields.push_back(m_actual_aggregated_yield);
 
 
     double min_need_satisfaction1 = cfg_Min_need_satisfaction1.value(); 
     double min_need_satisfaction2 = cfg_Min_need_satisfaction2.value();  
     if(cfg_OnlyDeliberation.value()){ //then everybody deliberates (and: min cert is set to 0 when config var OnlyDeliberation is set to true)
         min_need_satisfaction1 = 100;
         min_need_satisfaction2 = 100;
     }
 
     if(m_main_goal == tofg_profit || m_main_goal == tofg_environment){
         if(m_exp_profit>0){
             if(m_actual_profit >= min_need_satisfaction1*m_exp_profit){
                 m_need_satisfaction_level=1;
             }
             else{
                 m_need_satisfaction_level=0;
             }
         }
         else if(m_exp_profit<0){
             if(m_actual_profit >= (2 - min_need_satisfaction1) * m_exp_profit){ //e.g. EP=-1000, AP=-1100 -> ok for MNS<=0.9.
                 m_need_satisfaction_level=1;
             }
             else{
                 m_need_satisfaction_level=0;
             }
         }
         else{ //exp profit = 0
             m_need_satisfaction_level  = (m_actual_profit >0)? 1 : 0; //need to deal with this case - not very likely to happen
         }
     }
     else if (m_main_goal == tofg_yield){
         m_need_satisfaction_level = (m_actual_aggregated_yield >= m_exp_aggregated_yield * min_need_satisfaction2)? 1 : 0 ;
     }
 
     m_previous_satisfaction_levels.push_back(m_need_satisfaction_level); //add it to the list of satisfaction levels from last 5 years
     if(m_previous_satisfaction_levels.size()>5){ // it's been more than 5 years since the first accoutning, so...
         m_previous_satisfaction_levels.erase(m_previous_satisfaction_levels.begin()); //remove the first element: satisfaction level 6 years ago
     }
 
     //for energy maize impact on wildlife - January 2014
     if(cfg_MaizeEnergy.value()){
         double threshold = cfg_AnimalsThreshold.value();
         double sum = 0;
         for(int i=0; i<m_animals_numbers.size(); i++){
             sum += m_animals_numbers[i];
         }
         double avrg_animals_no = 0;
         if(m_animals_numbers.size()>0){
             avrg_animals_no = sum/m_animals_numbers.size();
         }
 
         if(emaize && animals_no < threshold * avrg_animals_no && m_animals_numbers.size()>2){ //three conditions: 1. you actually have grown energy maize 
             // 2. the animal numbers have decreased below the acceptable level 3. you have data on animal numbers from min. 3 years
             //then set the rotation max. for energy maize to zero and force deliberation to stop growing energy maize
             CropOptimised *em = findCropByName_almass ("Maize"); 
             em->m_rotationMax = 0;
             force_deliberation = true;
         }
         m_animals_numbers.push_back(animals_no);
         if(m_animals_numbers.size() > 3){ //have data for more than 3 years now
             m_animals_numbers.erase(m_animals_numbers.begin()); //remove the oldest data - first element
         }
 
         //force optimisation when energy maize price changed by more than a given %
         double EMPrice_lastyr = m_OurManager->pm_data->Get_sellingPrice_lastyr(tov_Undefined*tos_Foobar*m_farmType + tov_Undefined*m_soilType + tov_Maize); 
         double EMPrice_current = m_OurManager->pm_data->Get_sellingPrice(tov_Undefined*tos_Foobar*m_farmType + tov_Undefined*m_soilType + tov_Maize); 
         if(abs(EMPrice_current - EMPrice_lastyr) > EMPrice_lastyr * cfg_PriceChangeThreshold.value()){
             force_deliberation = true;
         }
     }
     //
 
     //and restart the actual and expected values - for next year
     m_exp_income = 0;
     m_exp_costs = 0;
     m_exp_profit = 0;
     //exp agg yield is determined at the begininng of this function;
     m_actual_income = 0;
     m_actual_costs = 0;
     m_actual_profit = 0;
     m_actual_aggregated_yield = 0;
 
 }

void OptimisingFarm::assignFixed ( )

protected

Adds areas of fixed crops to the variable m_assigned. For each fixed crop it saves its area under variable CropOptimised::m_areaPercent.

Function assigning to fixed crops their initial areas as percentages of a farm's total area. It determines the share of a farm (%) reserved for fixed crops - excluded from the optimisation - and saves it in a variable m_assigned.

Definition at line 5798 of file farm.cpp.

References cfg_UseBedriftsmodelFarmAreas, m_area_scaling_factor, m_assigned, m_fixedCrops, m_totalArea, and CfgBool::value().

Referenced by OptimiseFarm().

                                 {
 
     m_assigned = 0;
     for (int i=0; i<(int)m_fixedCrops.size(); i++){//take only crops that are fixed
         double area = m_fixedCrops[i]->m_initialArea;
 
         if(!cfg_UseBedriftsmodelFarmAreas.value()){ //almass farm areas are in use, so scale the fixed crop area
             area *= m_area_scaling_factor;
         }
 
         double areaPercent= area/m_totalArea*100;
         m_fixedCrops[i]->m_areaPercent = areaPercent; //assign initial area in % for fixed crops
         m_assigned += areaPercent;//add areaPercent of a fixed crop to assigned
     }//now assigned is a number <0, 100> - excluded from the optimisation
 }

void OptimisingFarm::Check_if_area_100 ( )

protected

Checks if the sum of crops' areaPercent is 100%.

Determines the sum of all crops' CropOptimised::m_areaPercent. If the sum is not equal to 100, it issues a warning in a "Check_if_area_is_100%.txt" file.

Definition at line 7583 of file farm.cpp.

References m_almass_no, and m_crops.

Referenced by OptimiseFarm().

                                       {
     double area_to_check = 0.0;
     for(int i=0; i<(int)m_crops.size(); i++) {
         area_to_check += m_crops[i]->m_areaPercent;
     }
 
     if(area_to_check > 100.0001 || area_to_check < 99.999){ //issue a warning
         ofstream ofile("Check_if_area_is_100%.txt",ios::app); 
         ofile << m_almass_no << '\t' << "Farms area is not equal to 100%. The sum of crops areaPercent is: " << area_to_check << endl;
         ofile.close();
     }
 }

void OptimisingFarm::Check_SG_and_CGG ( )

protected

Modifies areas of SeedGrass1 and SeedGrass2, CloverGrassGrazed1 and CloverGrassGrazed2 to be even. Used only in ALMaSS crops mode (in Bedriftsmodel (original farm optimization model) crops mode this is taken care of in Translate_crops_to_almass()).

Definition at line 5400 of file farm.cpp.

References findCropByName_almass(), CropOptimised::m_areaPercent, CropOptimised::m_areaVariable, and CropOptimised::m_rotationMin.

Referenced by checkRestrictions().

                                      {
 
     CropOptimised *CGG1 = findCropByName_almass("CloverGrassGrazed1");
     CropOptimised *CGG2 = findCropByName_almass("CloverGrassGrazed2");
     CropOptimised *GS1 = findCropByName_almass("SeedGrass1");
     CropOptimised *GS2 = findCropByName_almass("SeedGrass2");
 
     double CGG1area = CGG1->m_areaPercent;
     double CGG2area = CGG2->m_areaPercent;
     double GS1area = GS1->m_areaPercent;
     double GS2area = GS2->m_areaPercent;
     if(CGG1area!= CGG2area){ //even if this is a cattle farm - where CGG are fodder - it won't have any effect here since the areas are zero or at min, so there won't be any change.
         double area_sum = CGG1area + CGG2area;
         double CGG1min = CGG1->m_rotationMin; double CGG2min = CGG2->m_rotationMin;
         CGG1->m_areaPercent = area_sum/2; CGG2->m_areaPercent = area_sum/2;
         CGG1->m_areaVariable = area_sum/2 - CGG1min; CGG2->m_areaVariable = area_sum/2 - CGG2min;
     }
     if(GS1area!=GS2area){
         double area_sum = GS1area + GS2area;
         double GS1min = GS1->m_rotationMin; double GS2min = GS2->m_rotationMin;
         GS1->m_areaPercent = area_sum/2; GS2->m_areaPercent = area_sum/2;
         GS1->m_areaVariable = area_sum/2 - GS1min; GS2->m_areaVariable = area_sum/2 - GS2min;
     }
 }

void OptimisingFarm::checkRestrictions ( )

protectedvirtual

Checks if the restrictions are fulfilled and corrects crops' areas if necessary.

Function checking if restrictions concerning crop rotations are fulfilled. If not, it corrects the crop areas in order to fulfill the restrictions. It starts with checking the restriction on winter crops rotation. Then it checks restriction on max winter crops' area. Finally, for cattle farms it checks the restriction on crop rotation.

The order of checking the first two restrictions does matter: in case the first restriction is not fullfilled, the first function always decreases winter wheat's area and only in a particular case increases area of winter rape. Thus, the total area of winter crops (->second restriction) most likely is decreased or, otherwise - unchanged by the function dealing with the first restriction. The second restriction, on max area of winter crops, does not allow to decrease area of winter rape; this, in certain cases, might result in suboptimal final result, but ensures that the first restriction is not violated. In the third restriction (only in the version for cattle farms) in the Bedriftsmodel crop mode, winter wheat is removed from the list of crops which is used to fill up the gap after decreasing some of the restriction crops.

In the ALMaSS crops mode the third restriction (for cattle farms) is implemented in a simplified version, i.e. it is limited to changing only areas of crops that form the restriction. Additionally, in the ALMaSS crops mode there is a function which ensures that areas of both CloverGrassGrazed1 and CloverGrassGrazed2 as well as SeedGrass1 and SeedGrass2 are equal (since '1' and '2' are the same crops, but with different management in the first and next year they are grown).

Reimplemented in OptimisingCattleFarm, and OptimisingPigFarm.

Definition at line 5933 of file farm.cpp.

References cfg_Areas_Based_on_Distribution, cfg_OptimiseBedriftsmodelCrops, Check_SG_and_CGG(), NonAnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterRotation1(), and CfgBool::value().

Referenced by OptimisingPigFarm::checkRestrictions(), OptimisingCattleFarm::checkRestrictions(), and OptimiseFarm().

                                       {
     //1st restriction: winter rotation
     if(!cfg_Areas_Based_on_Distribution.value()){ //if this is true, skip this restriction
         checkWinterRotation1();
     }
 
     //2nd restriction: max share of winter crops area
     checkWinterCrops(); 
 
     if (!cfg_OptimiseBedriftsmodelCrops.value()){ //just for almass crop mode: make sure cgg1 and cgg2, sgg1 and sgg2 - have equal areas. added 26.03.13 -function since 110613
         Check_SG_and_CGG();
     }
 }

virtual void OptimisingFarm::checkWinterCrops ( )

inlineprotectedvirtual

Checks if the restriction on a max. share of winter crops is fulfilled.

Reimplemented in NonAnimalFarm, and AnimalFarm.

Definition at line 2189 of file farm.h.

2189 {};

virtual void OptimisingFarm::checkWinterRotation1 ( )

inlineprotectedvirtual

Checks if the restriction on a winter rotation is fulfilled.

Reimplemented in NonAnimalFarm, and AnimalFarm.

Definition at line 2187 of file farm.h.

2187 {};

void OptimisingFarm::ChooseDecisionMode ( )

Function determines which decision mode to use. The choice depends on the values of need satisfaction and uncertainty.

In the first year the function is called (8), it calls Find_neighbour_to_imitate. Every year it determines a farmer's certainty level. Depending on farmer's satisfaction and certainty levels it picks a decision mode: imitation if a farmer is uncertain, but satisfied; social comparison if a farmer is uncertain and not satisfied; repetition if a farmer is certain and satisifed; or deliberation if a farmer is certain, but not satisifed.

Definition at line 5001 of file farm.cpp.

References cfg_Min_certainty, cfg_OnlyDeliberation, Find_neighbour_to_imitate(), force_deliberation, g_date, Get_actual_aggregated_yield(), Get_actual_profit(), Get_rotational_crops_visible(), Calendar::GetYearNumber(), m_certainty_level, m_decision_mode_counters, m_main_goal, m_need_satisfaction_level, m_previous_satisfaction_levels, m_previously_imitated_neighbour, m_rotational_crops, m_rotational_crops_copy, m_totalFUdemand, m_totalFUdemandBefore, m_totalFUgrown, Make_almass_crops_vector(), Make_rotational_crops(), OptimiseFarm(), tofg_environment, tofg_profit, tofg_yield, tov_Undefined, CfgFloat::value(), and CfgBool::value().

Referenced by FarmManager::ChooseDecisionMode_for_farms().

                                        {
     //pick a farmer to copy (imitation startegy)/ or compare with and possibly copy (social comparison strategy) if this is the first time this function is called: year 8
     if(g_date->GetYearNumber() == 8){
         Find_neighbour_to_imitate();
     }
 
     //1. get the values of parameters
     double min_certainty = cfg_Min_certainty.value(); 
     if(cfg_OnlyDeliberation.value()) min_certainty = 0; 
 
     //2. determine the satisfaction level: already done in the ActualProfit()
 
     //3. determine the certainty level
     double sum_of_sat_levels=0;
     for(int i=0; i<5; i++){
         sum_of_sat_levels += m_previous_satisfaction_levels[i];
     }
     m_certainty_level = sum_of_sat_levels/5.0; // i.e. take 5 years into account
 
     //4. choose the decision mode
     //'if' for forcing deliberation:
     if(force_deliberation){ //do the same as when deliberation is chosen normally
         m_decision_mode_counters[3]++;
         m_totalFUdemand=m_totalFUdemandBefore; //restart the fodder demand to the original value
         m_totalFUgrown = 0; //restart
         OptimiseFarm(tov_Undefined);
         Make_almass_crops_vector(); //makes m_crops_almass
         Make_rotational_crops(); //makes new m_rotational_crops - based on m_crops_almass
         m_rotational_crops_copy = m_rotational_crops;
         force_deliberation=false;
     }
     else{
         if(m_certainty_level < min_certainty){
             if(m_need_satisfaction_level  == 1 ){                       //IMITATION (high sat., low cert.)
                 m_decision_mode_counters[0]++;
                 //now imitate:
                 m_rotational_crops = m_previously_imitated_neighbour->Get_rotational_crops_visible();
                 m_rotational_crops_copy = m_rotational_crops; //m_rotational_crops_copy is used for finding a crop for a given field - in Match_crop_to_field function.
             } //imitation over
 
             else{                                                       //SOCIAL COMPARISON - similar to imitation, but includes comparison (low sat., low cert.)
                 m_decision_mode_counters[1]++;
                 //compare yourself to the neighbour: this depends on your goal
                 bool imitate=false;
                 if(m_main_goal == tofg_profit){
                     if(m_actual_profit < m_previously_imitated_neighbour->Get_actual_profit()){
                         imitate=true;
                     }
                 }
                 else if (m_main_goal == tofg_yield){
                     if(m_actual_aggregated_yield < m_previously_imitated_neighbour->Get_actual_aggregated_yield()){
                         imitate=true;
                     }
                 }
                 else if (m_main_goal == tofg_environment) {
                     if(m_actual_aggregated_yield < m_previously_imitated_neighbour->Get_actual_aggregated_yield() && m_actual_profit < m_previously_imitated_neighbour->Get_actual_profit()){//compare both
                         imitate=true;
                     }
                 }
 
                 if(imitate){
                     m_rotational_crops = m_previously_imitated_neighbour->Get_rotational_crops_visible();
                 }
                 //else: just continue
                 m_rotational_crops_copy = m_rotational_crops; //this happens for both cases - imitate or not
             } //social comparison over
         } //high uncertainty
 
         else{ //low uncertainty (= high certainty)
             int value_for_satisfaction = 1; //1 for a simulation with not only deliberation
             if(cfg_OnlyDeliberation.value()) value_for_satisfaction = 10; //10 - then everybody deliberates 
             if(m_need_satisfaction_level == value_for_satisfaction){                            //REPETITION (high sat., high cert.)
                 m_decision_mode_counters[2]++;
                 //continue with the same set of crops - see line after else!
             }
             else{                                                       //DELIBERATION - i.e. optimise to make a new m_rotational_crops (low sat., high cert.)
                 m_decision_mode_counters[3]++;
                 m_totalFUdemand=m_totalFUdemandBefore; //restart the fodder demand to the original value
                 m_totalFUgrown = 0; //restart
                 OptimiseFarm(tov_Undefined);
                 Make_almass_crops_vector(); //makes m_crops_almass
                 Make_rotational_crops(); //makes new m_rotational_crops - based on m_crops_almass
             }
             m_rotational_crops_copy = m_rotational_crops; //do this for both cases
         }
     }
 }

void OptimisingFarm::createCropsLists ( int a_foobar )

protectedvirtual

Creates lists of crops.

Reimplemented in AnimalFarm.

Definition at line 5093 of file farm.cpp.

References createVariableCrops().

Referenced by Init().

                                                  {
     createVariableCrops(a_foobar);
 }

void OptimisingFarm::createVariableCrops ( int a_foobar )

protected

Creates a list of pointers to all variable crops included in the optimisation and a list of pointers to fixed crops.

Creates two vectors: vector of pointers to fixed crops and a vector of structs containing variable crops.

Definition at line 5102 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, DataForOptimisation::Get_fixed(), m_crops, m_farmType, m_fixedCrops, Farm::m_OurManager, m_variableCrops, FarmManager::pm_data, and CfgBool::value().

Referenced by createCropsLists(), and AnimalFarm::createCropsLists().

                                                     {
     int n = (int)m_crops.size();
     for (int i=0; i < n; ++i) {
         int crop_type=(cfg_OptimiseBedriftsmodelCrops.value())? (int)m_crops[i]->m_cropType : (int)m_crops[i]->m_cropType_almass;
         int index=a_foobar*m_farmType + crop_type;
         if (m_OurManager->pm_data->Get_fixed(index)){ //if the crop is fixed, attach it to the list fixedCrops
             m_fixedCrops.push_back(m_crops[i]);
         }
         else{
             CropSort cs = {0., m_crops[i]}; //an object with a key and a pointer to crop
             m_variableCrops.push_back(cs);
         }
     }
 }

double OptimisingFarm::crop_parameter	(	int	index,
		string	par_name
	)

protected

Reads in crop parameters that do NOT vary with any farm level parameters.

Definition at line 7279 of file farm.cpp.

References DataForOptimisation::Get_cropParameter(), Farm::m_OurManager, FarmManager::pm_data, top_Foobar, and FarmManager::TranslateParametersCodes().

Referenced by ActualProfit(), findBIs(), findGrossMargin(), findMWeedControl(), and findYieldLoss().

                                                                {
     double par_value;
     par_value = m_OurManager->pm_data->Get_cropParameter(top_Foobar*index + m_OurManager->TranslateParametersCodes(par_name));
     return  par_value;
 }

void OptimisingFarm::decreaseCrops	(	vector< CropSort >	cropsToDecrease,
		double &	howMuchToDecrease
	)

protectedvirtual

Decreases area of a crops by a specified number.

Function decreases area of one or more crops from the list given as a first argument.The total area subtracted from the crops in the list is equal to the value of the second argument.

Reimplemented in AnimalFarm.

Definition at line 7435 of file farm.cpp.

Referenced by OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation(), OptimisingCattleFarm::checkCattleRotation_almass(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), NonAnimalFarm::checkWinterRotation1(), and AnimalFarm::determineMinFodder().

                                                                                             {
     for(int j=(int)cropsToDecrease.size()-1; howMuchToDecrease>0 && j>=0; j--){ //start with the worst
         double areaCrop = cropsToDecrease[j].crop->m_areaPercent;
         double rotMinCrop = cropsToDecrease[j].crop->m_rotationMin;
         if(areaCrop - howMuchToDecrease >= rotMinCrop){
             areaCrop -= howMuchToDecrease;
             howMuchToDecrease = 0; //finito
         }
         else{
             howMuchToDecrease -= areaCrop - rotMinCrop;
             areaCrop = rotMinCrop;
         }
         cropsToDecrease[j].crop->m_areaPercent = areaCrop;
         cropsToDecrease[j].crop->m_areaVariable = areaCrop - rotMinCrop; 
     }
 }

void OptimisingFarm::determineAreas ( int a_foobar )

protectedvirtual

Determines areas of variable crops.

Function determining areas of all not fixed, non-fodder crops at a farm as percentages of a farm's total area. It goes through a list of variable crops sorted from the highest to the lowest Gross Margin (i.e., most to least profitable) and assigns a maximal allowed area for each non-fodder crop - until the remaining farm's area is equal to or lower than a maximal allowed area for a given crop. In such case it assigns the remaining area to this crop. All remaining crops are assigned areas equal to zero (above their minimal required areas).

If the cfg_Areas_Based_on_Distribution variable is set to true, the area is assigned on the basis og each crop's GM proportion in the summary GM based on crops with a positive GM.

Reimplemented in AnimalFarm.

Definition at line 5827 of file farm.cpp.

References cfg_Areas_Based_on_Distribution, cfg_OptimiseBedriftsmodelCrops, DataForOptimisation::Get_fodder(), m_assigned, m_farmType, m_grownVariableCrops, Farm::m_OurManager, m_variableCrops, FarmManager::pm_data, and CfgBool::value().

Referenced by AnimalFarm::determineAreas(), and OptimiseFarm().

                                                {
     m_grownVariableCrops.clear();
 
     for(int i=0; i<(int)m_variableCrops.size(); i++){
         double areaPercent=0;
         double minArea=m_variableCrops[i].crop->m_rotationMin;
 
         int index1 = (cfg_OptimiseBedriftsmodelCrops.value())? a_foobar*m_farmType + m_variableCrops[i].crop->m_cropType : a_foobar*m_farmType + m_variableCrops[i].crop->m_cropType_almass;
 
         //next two lines necessary for animal farms' function version
         bool fodder = m_OurManager->pm_data->Get_fodder(index1);
         if (!fodder){ //this should be checked for animal farms, for other and plant - will always be false
             if (m_assigned<100){ //check if there is any area left at a farm
                 double rotationMax = m_variableCrops[i].crop->m_rotationMax; //same as in else
 
                 if(cfg_Areas_Based_on_Distribution.value()){ //added 170713
 
                     double GMsum = 0;
                     for(int k=i; k<(int)m_variableCrops.size(); k++){ //do it for each crop (calculate prob) to avoid getting area without any crop. Start with the current crop (k=i), i.e. exclude the crops that are already assigned area.
                         if(m_variableCrops[k].crop->m_GM > 0 && m_variableCrops[k].crop->m_rotationMax>0){ //make sure you dont include crops that have rot max set to zero! then the area won't sum up to 100%
                             GMsum += pow (m_variableCrops[k].crop->m_GM, 1);
                         }
                     }
                     double base_prob = 0;
                     if(m_variableCrops[i].crop->m_GM > 0){
                         base_prob = pow(m_variableCrops[i].crop->m_GM, 1)/GMsum;
                     }
                     else base_prob = 0;
 
                     //draw a random number
                     std::random_device rd;
                     distribution_type3 dis(-1.0, 1.0);
                     std::mt19937 engine(rd());
                     double random_number = dis(engine);
                     if(base_prob == 1) random_number = 0; // this is the last crop on the list - don't manipulate the area
                     double area_1 = base_prob * (1 + 0.2 * random_number) * (100 - m_assigned); //take only a percent of the remaining area!
                     areaPercent = ( area_1 <= rotationMax)? area_1 : rotationMax;
                     if (areaPercent > 100 - m_assigned) areaPercent = 100 - m_assigned; //added 280813
 
                 }
                 else{ //standard area assignment
                     areaPercent = (rotationMax-minArea <= 100-m_assigned)? rotationMax : (100 - m_assigned+minArea); //check if the remaining area (100-assigned) is enough to assign max allowed area for a crop (max-min, which was already assigned, if not - assign the remaining area+min area
                 }
 
                 m_assigned += areaPercent - minArea; //add the assigned area (final area percent minus minimum; minimum was assigned before) to the total assigned area
                 if(areaPercent>minArea){m_grownVariableCrops.push_back(m_variableCrops[i].crop);} //this might not be used for other than animal farms...but maybe - it would be nice to have such a list anyway
 
             }//m_assigned < 100
 
             else {areaPercent = minArea;}
 
             m_variableCrops[i].crop->m_areaPercent = areaPercent;
             double areaVar=areaPercent-minArea;
             m_variableCrops[i].crop->m_areaVariable = areaVar; //save the value of the area that can be changed! For farms other than animal this maybe could be used just in restrictions functions...
         }
         else{ //it is a fodder crop, so just save its min area under areaPercent
             m_variableCrops[i].crop->m_areaPercent = minArea;
         }
     }
 }

void OptimisingFarm::determineAreas_ha ( vector< CropOptimised * > crops )

protected

Determines areas of crops in ha.

Determines areas of crops in ha: CropOptimised::m_area_ha = CropOptimised::m_areaPercent/100 * m_totalArea.

Definition at line 7490 of file farm.cpp.

References m_totalArea.

Referenced by OptimiseFarm().

                                                                     { //area in ha
     for(int i=0; i<(int)allCrops.size(); i++){
         double areaPercent = allCrops[i]->m_areaPercent;
         double area_ha = (areaPercent==0) ? 0 : (areaPercent/100 * m_totalArea);
         allCrops[i]->m_area_ha = area_ha;
     }
 }

void OptimisingFarm::FarmLevelCalculation ( )

protected

Calls functions determining farm level values before the initial optimisation.

Calls functions determining farm level values before the initial optimisation (i.e.: amount of animal fertilizer (total - m_totalNanim, and per ha - m_Nanim), farm's area - m_totalArea, and fodder demand - m_totalFUdemand).

Definition at line 5136 of file farm.cpp.

References cfg_Areas_Based_on_Distribution, NonAnimalFarm::findFodderDemand(), findNanim(), findTotalArea(), findTotalNanim(), preventCashCrops(), and CfgBool::value().

Referenced by Init().

                                           {
 
      findTotalArea();
      findTotalNanim();
      findNanim();
      findFodderDemand(); //this function cannot be called in the constructor!
      if(cfg_Areas_Based_on_Distribution.value()){
          preventCashCrops();
      }
 }

OptimisingFarm * OptimisingFarm::Find_neighbour_to_imitate ( )

Picks randomly a farmer to imitate/compare with. It chooses among neighbouring farmers with similar farms.

Chooses a farmer for imitation and social comparison decision making modes. For business (>10 ha) farms it chooses a farmer with the same farm type and soil type. For private (<10 ha) farms it chooses a farmer with the same soil type.

Definition at line 4903 of file farm.cpp.

References g_msg, Get_farmSize(), Get_soilType(), m_almass_no, m_farmSize, m_farmType, m_neighbours, m_previously_imitated_neighbour, m_rotational_crops_visible, m_soilType, tofs_Private, tos_Clay, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by ChooseDecisionMode().

                                                           {
 
     int no_farmers = (int)m_neighbours.size();
 
     if(no_farmers!=0){ //if the list is empty - no neighbours
         bool ok=false;
         vector<OptimisingFarm*>neighbours_copy = m_neighbours;
         for(int a=0; ok==false && neighbours_copy.size()>0; a++){
             srand ((unsigned)time(NULL)); //warning?
             int neighbour = rand() % (no_farmers-a); //returns a random int number from the range: <0, no_farmers-1-a> - need to subtract those remved from the list-there is 'a' removed neighbours
             m_previously_imitated_neighbour = neighbours_copy[neighbour];
             if(m_farmSize==tofs_Private){ //then look just at the soil type 
                 if(m_soilType!=tos_Clay){ //private with sand or other soil
                     if(m_previously_imitated_neighbour->Get_soilType()!=tos_Clay && m_previously_imitated_neighbour->Get_farmSize()==m_farmSize &&
                         m_previously_imitated_neighbour->m_rotational_crops_visible.size()!=0){
                         ok=true; //found somebody to imitate
                     }
                     else{
                         neighbours_copy.erase(neighbours_copy.begin() + neighbour);
                     }
                 }
                 else{ //private with clay
                     if(m_previously_imitated_neighbour->Get_soilType()==this->Get_soilType()
                         && m_previously_imitated_neighbour->m_rotational_crops_visible.size()!=0){
                         ok=true; //found somebody to imitate
                     }
                     else{
                         neighbours_copy.erase(neighbours_copy.begin() + neighbour);
                     }
                 }
             }
             else if(m_soilType!=tos_Clay){ //business farm with sand or other soil
                 if(m_previously_imitated_neighbour->Get_soilType()!=tos_Clay && m_previously_imitated_neighbour->Get_farmSize()==m_farmSize &&
                     m_previously_imitated_neighbour->m_rotational_crops_visible.size()!=0 && m_previously_imitated_neighbour->m_farmType == m_farmType){ //the last condition added 210613
                     ok=true; //found somebody to imitate
                 }
                 else{
                     neighbours_copy.erase(neighbours_copy.begin() + neighbour);
                 }
             }
             else{ //business farm with clay soil
                 if(m_previously_imitated_neighbour->Get_soilType()==m_soilType && m_previously_imitated_neighbour->Get_farmSize()==m_farmSize &&
                     m_previously_imitated_neighbour->m_rotational_crops_visible.size()!=0 && m_previously_imitated_neighbour->m_farmType == m_farmType){ //the last condition added 210613  ){
                     ok=true; //found somebody to imitate
                 }
                 else{
                     neighbours_copy.erase(neighbours_copy.begin() + neighbour);
                 }
             }
 
         }
         if(ok==true){ //found a neighbouring farmer to imitate
             return  m_previously_imitated_neighbour;
         }
         else{ //try to find a neighbour with at least the same farm type
             neighbours_copy = m_neighbours; //first restart the neighbours copy!
             for(int a=0; ok==false && neighbours_copy.size()>0; a++){ //040713 - do not accept a farm with empty rot crops
                 srand ((unsigned)time(NULL)); //warning?
                 int neighbour = rand() % (no_farmers-a); //returns a random int number from the range: <0, no_farmers-1-a> - need to subtract those remved from the list-there is 'a' removed neighbours
                 m_previously_imitated_neighbour = neighbours_copy[neighbour];
                 if(m_previously_imitated_neighbour->m_rotational_crops_visible.size()!=0 && m_previously_imitated_neighbour->m_farmType == m_farmType){ //ok
                     ok=true; 
                 }
                 else{ 
                     neighbours_copy.erase(neighbours_copy.begin() + neighbour);
                 }
             }           
             if(ok==true){
                 return  m_previously_imitated_neighbour;
             }
             else{
                 m_previously_imitated_neighbour = this; //no neighbour that fits - copy yourself
                 #ifdef _DEBUG
                 char errornum[ 20 ];
                 sprintf( errornum, "%d", m_almass_no );
                 g_msg->Warn( WARN_BUG, "No farm with a matching farm type to imitate: ", errornum );
                 #endif
                 return  m_previously_imitated_neighbour;
             }
         }
     }
 
 
     else{ //no neighboring farmers //just set yourself
         m_previously_imitated_neighbour = this;
         return  m_previously_imitated_neighbour;
     }
 }

void OptimisingFarm::findBIs	(	CropOptimised *	a_crop,
		double	benefit
	)

protected

Determines the optimal Treatment frequency indices (behandling index, BI in Danish) (CropOptimised::m_BIHerb, CropOptimised::m_BIFi, CropOptimised::m_BI) for a given crop at a farm.

Function determining the optimal 'behandling indeks' (treatment frequency index) for herbicides (CropOptimised::m_BIHerb), fungicides and insecticides (CropOptimised::m_BIFi), and a summary BI per ha (CropOptimised::m_BIHerb). For each crop there is a specified amount of herbicides, fungicides and insecticides for which the yield loss is equal to zero. The farmer can choose between this value and not using pesticide at all (since yield and profit are linear functions of pesticide usage). However, when a given crop is actually grown, farmer might not apply pesticide if there is no pest problem (even though he originally planned to apply pesticides), or might apply more than he planned to if there is an excess pest problem. Therefore, there is a variation in the actual pesticide usage between farmers.

Definition at line 5570 of file farm.cpp.

References cfg_Env_pest_multiplier, cfg_OptimiseBedriftsmodelCrops, crop_parameter(), CropOptimised::m_BI, CropOptimised::m_BIFi, CropOptimised::m_BIHerb, CropOptimised::m_cropType, CropOptimised::m_cropType_almass, m_main_goal, CropOptimised::m_resp, tofg_environment, tofg_profit, tofg_yield, CfgFloat::value(), and CfgBool::value().

Referenced by optimizeCrops().

                                                                   { 
     int index = (cfg_OptimiseBedriftsmodelCrops.value())? (int)a_crop->m_cropType : (int)a_crop->m_cropType_almass;
 
     double alfaFi = crop_parameter(index, "AlfaFi");
     double alfaHerb = crop_parameter(index, "AlfaHerb");
     double alfaG = crop_parameter(index, "AlfaG");
     double alfaH = crop_parameter(index, "AlfaH");
     double alfaW = crop_parameter(index, "AlfaW");
     double betaFi = crop_parameter(index, "BetaFi");
     double betaHerb = crop_parameter(index, "BetaHerb");
 
     double priceFi = crop_parameter(index, "PriceFi");
     double priceHerb = crop_parameter(index, "PriceHerb");
     double priceG = crop_parameter(index, "PriceG");
     double priceH = crop_parameter(index, "PriceH");
     double priceW = crop_parameter(index, "PriceW");
 
     double resp1=a_crop->m_resp;
 
     if(alfaHerb>0){//make sure it is not zero!it is for Fodder beet
         double BIHerbMax = betaHerb/alfaHerb;
         double gainHerb = 0;
         double BIHerb = 0;
 
         if(m_main_goal == tofg_profit){
             gainHerb = benefit*resp1*alfaHerb/100 + priceG*alfaG + priceH*alfaH + priceW*alfaW;
             BIHerb = (gainHerb>priceHerb)? BIHerbMax : 0;
             a_crop->m_BIHerb = BIHerb;
         }
         else if (m_main_goal == tofg_yield){
             a_crop->m_BIHerb = BIHerbMax; //12.12.12
         }
         else if (m_main_goal == tofg_environment){ 
             gainHerb = benefit*resp1*alfaHerb/100 + priceG*alfaG + priceH*alfaH + priceW*alfaW;
             BIHerb = (gainHerb> (priceHerb * cfg_Env_pest_multiplier.value()))? BIHerbMax : 0; 
             a_crop->m_BIHerb = BIHerb;
         }
     }
     else a_crop->m_BIHerb = 0; //BI for fodder beet in the original model (Bedriftsmodel) 
 
     if(alfaFi>0){
         double BIFiMax = betaFi/alfaFi;
         double gainFi = 0;
         double BIFi = 0;
         if(m_main_goal == tofg_profit){
             gainFi = benefit*resp1*alfaFi/100;
             BIFi = (gainFi > priceFi) ? BIFiMax : 0;
             a_crop->m_BIFi = BIFi;
         }
         else if (m_main_goal == tofg_yield){
             a_crop->m_BIFi = BIFiMax;
         }
         else if (m_main_goal == tofg_environment){ 
             gainFi = benefit*resp1*alfaFi/100;
             if (gainFi > (priceFi * cfg_Env_pest_multiplier.value())){ 
                 BIFi = BIFiMax;
             }
             else{
                 BIFi = 0;
             }
             a_crop->m_BIFi = BIFi;
         }
     }
     else a_crop->m_BIFi = 0;
 
     double BIFi = a_crop->m_BIFi;
     double BIHerb = a_crop->m_BIHerb;
     double BI = BIFi+BIHerb;
     a_crop->m_BI = BI;
 }

CropOptimised * OptimisingFarm::findCropByName ( string crop_name )

protected

Returns a pointer to a crop whose name is specified as the argument (bedriftsmodel, i.e. original farm optimization model, crops mode).

Definition at line 7285 of file farm.cpp.

References g_msg, m_crops, Farm::m_OurManager, FarmManager::TranslateCropsCodes(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by OptimisingCattleFarm::checkCattleRotation(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), NonAnimalFarm::checkWinterRotation1(), fixBI(), and Make_rotations().

                                                                {
     for(int c=0; c< (int)m_crops.size(); c++){
         if(m_crops[c]->m_cropType==m_OurManager->TranslateCropsCodes(crop_name)) return m_crops[c];
     }
     g_msg->Warn( WARN_FILE, "OptimisingFarm::findCropByName():" "Unknown Code Identificator", crop_name.c_str() );
     exit(0);
 }

CropOptimised * OptimisingFarm::findCropByName_almass ( string crop_name )

protected

Returns a pointer to almass crop whose name is specified as the argument (ALMaSS crops mode).

Definition at line 7293 of file farm.cpp.

References g_msg, m_crops, Farm::m_OurManager, FarmManager::TranslateCropCodes(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by ActualProfit(), Check_SG_and_CGG(), OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation_almass(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), NonAnimalFarm::checkWinterRotation1(), fixBI(), Make_rotations(), OptimisingCattleFarm::preventCashCrops(), Spraying_fungins(), and Spraying_herbicides().

                                                                       {
     for(int c=0; c< (int)m_crops.size(); c++){
         if(m_crops[c]->m_cropType_almass == m_OurManager->TranslateCropCodes(crop_name)) return m_crops[c];
     }
     g_msg->Warn( WARN_FILE, "OptimisingFarm::findCropByName_almass():" "Unknown Code Identificator", crop_name.c_str() );
     exit(0);
 }

CropOptimised * OptimisingFarm::findCropByName_almass ( TTypesOfVegetation a_tov_type )

protected

Returns a pointer to almass crop whose tov type is specified as the argument.

Definition at line 7301 of file farm.cpp.

References g_msg, m_crops, MapErrorMsg::Warn(), and WARN_BUG.

                                                                                    {
     for(int c=0; c< (int)m_crops.size(); c++){
         if(m_crops[c]->m_cropType_almass == a_tov_type) return m_crops[c];
     }
     char error_num[ 20 ];
     sprintf( error_num, "%d",  a_tov_type);
     g_msg->Warn( WARN_BUG, "OptimisingFarm::findCropByName_almass():" "Unknown Code Identificator", error_num );
     exit(0);
 }

void OptimisingFarm::findFertilizer	(	CropOptimised *	a_crop,
		int	a_foobar,
		double	benefit
	)

protected

Determines the optimal amounts of: total fertilizer (CropOptimised::m_n) and purchased fertilizer (CropOptimised::m_nt) for a given crop at a farm.

Function determining the optimal amounts of: total fertilizer (CropOptimised::m_n) and purchased fertilizer (CropOptimised::m_nt) per ha of a crop at a given farm. [kg/ha]

Definition at line 5429 of file farm.cpp.

References cfg_Env_fert_multiplier, cfg_OptimiseBedriftsmodelCrops, cfg_Price_Nt, DataForOptimisation::Get_beta1(), DataForOptimisation::Get_beta2(), DataForOptimisation::Get_Nnorm(), CropOptimised::m_cropType, CropOptimised::m_cropType_almass, m_main_goal, CropOptimised::m_n, m_Nanim, CropOptimised::m_nt, CropOptimised::m_optimalN, Farm::m_OurManager, m_soilType, FarmManager::pm_data, tofg_environment, tofg_profit, tofg_yield, CfgFloat::value(), and CfgBool::value().

Referenced by optimizeCrops().

                                                                                        {
 
     int index = (cfg_OptimiseBedriftsmodelCrops.value())? a_foobar * m_soilType + a_crop->m_cropType : a_foobar * m_soilType + a_crop->m_cropType_almass;
 
     double beta1=m_OurManager->pm_data->Get_beta1(index);
     double beta2=m_OurManager->pm_data->Get_beta2(index);
     double nNorm=m_OurManager->pm_data->Get_Nnorm(index);
     double priceNt=cfg_Price_Nt.value(); 
 
     if(!beta2==0){
         a_crop->m_optimalN = -(beta1/beta2)*0.5; //01.03.12 save the optimal free fertilizer 
     }
     else{ //if beta2 is =0, beta1 is also =0 -> so optimum is at 0.
         a_crop->m_optimalN = 0;
     }
 
     if(m_main_goal == tofg_profit){
 
         if(!beta2==0){ //beta2 is not 0
             double n1=-(beta1/beta2)*0.5; //optimal fertilizer supposing it's for free
             if(m_Nanim >= n1){ //there is more than you need, so check the norm:
                 if (n1<nNorm){
                    a_crop->m_n = n1; //apply optimal amount
                 }
                 else {
                    a_crop->m_n = nNorm; //apply max allowed amount
                 }
                 a_crop->m_nt = 0;  //don't buy fertilizer
             }
             else { //the optimal amount is larger than Nanim
                double nt1= 0.5*(priceNt/(benefit*beta2) - beta1/beta2) - m_Nanim; //optimal fertilizer Nt
                if (nt1>0){
                    double n2=nt1+m_Nanim; //optimal total N
                    if (n2<nNorm){
                      a_crop->m_nt = nt1;
                      a_crop->m_n = n2;
                    }
                    else {
                        double p=nNorm-m_Nanim;
                        if(p>=0){a_crop->m_nt = p;} //buy the diff between what you have (Nanim) and what is the max allowed
                        else{a_crop->m_nt = 0;}// your Nanim is higher than the norm!
                        a_crop->m_n = nNorm; //total amount is the max allowed, Nanim+(nNorm-Nanim)=nNorm
                    }
                }
                else { //it doesn't pay off to buy fertilizer, so just use Nanim
                    if(m_Nanim<=nNorm){a_crop->m_n = m_Nanim;} //apply fertilizer
                    else {a_crop->m_n = nNorm;}
                    a_crop->m_nt = 0;
                }
             }
         }
         else{ //beta2=0, so don't apply fertilizer, but in this model - apply Nanim if there is any
             if(m_Nanim<=nNorm){a_crop->m_n = m_Nanim;} //apply fertilizer
             else {a_crop->m_n = nNorm;}
             a_crop->m_nt = 0;
         }
 
     }
 
     else if (m_main_goal == tofg_yield) { //modified profit optimization algorithm
         if(!beta2==0){ //beta2 is not 0
             double n1=-(beta1/beta2)*0.5; //optimal fertilizer supposing it's for free
             if(m_Nanim >= n1){ //there is more than you need, so check the norm:
                 if (n1<nNorm){
                    a_crop->m_n = n1; //apply optimal amount
                 }
                 else {
                    a_crop->m_n = nNorm; //apply max allowed amount
                 }
                 a_crop->m_nt = 0;  //don't buy fertilizer
             }
             else { //the optimal amount is larger than Nanim
                 if(n1>=nNorm){
                     if(m_Nanim > nNorm){a_crop->m_nt = 0;}
                     else{a_crop->m_nt = nNorm - m_Nanim;}//buy the diff between what you have (Nanim) and what is the max allowed
                     a_crop->m_n = nNorm; //total amount is the max allowed
                 }
                 else{
                     a_crop->m_nt = n1 - m_Nanim;
                     a_crop->m_n = n1;
                 }
             }
         }
         else{ //beta2=0, so don't apply fertilizer, but in this model - apply Nanim if there is any
             if(m_Nanim<=nNorm){a_crop->m_n = m_Nanim;} //apply fertilizer
             else {a_crop->m_n = nNorm;}
             a_crop->m_nt = 0;
         }
 
     }
     else if (m_main_goal == tofg_environment) { //apply less than a norm: the code copied from yield max - the only change is in calculation of n1 - mulitplied by 0.8.
         if(!beta2==0){ //beta2 is not 0
             double n1=-(beta1/beta2)*0.5 * cfg_Env_fert_multiplier.value(); //optimal fertilizer supposing it's for free; multiplier - to make this type use less fertilizer
             if(m_Nanim >= n1){ //there is more than you need, so check the norm:
                 if (n1<nNorm){
                    a_crop->m_n = n1; //apply optimal amount
                 }
                 else {
                    a_crop->m_n = nNorm; //apply max allowed amount
                 }
                 a_crop->m_nt = 0;  //don't buy fertilizer
             }
             else { //the optimal amount is larger than Nanim
                 if(n1>=nNorm){
                     if(m_Nanim > nNorm){a_crop->m_nt = 0;}
                     else{a_crop->m_nt = nNorm - m_Nanim;}//buy the diff between what you have (Nanim) and what is the max allowed
                     a_crop->m_n = nNorm; //total amount is the max allowed
                 }
                 else{
                     a_crop->m_nt = n1 - m_Nanim;
                     a_crop->m_n = n1;
                 }
             }
         }
         else{ //beta2=0, so don't apply fertilizer, but in this model - apply Nanim if there is any
             if(m_Nanim<=nNorm){a_crop->m_n = m_Nanim;} //apply fertilizer
             else {a_crop->m_n = nNorm;}
             a_crop->m_nt = 0;
         }
     }
 }

void OptimisingFarm::findFodderDemand ( )

protectedvirtual

Determines farm's total demand for fodder (m_totalFUdemand).

Function determining farm's demand for fodder. Sums fodder needed for all types of livestock.

Reimplemented in NonAnimalFarm.

Definition at line 5193 of file farm.cpp.

References cfg_UseBedriftsmodelFarmAreas, DataForOptimisation::Get_livestockParameter(), m_area_scaling_factor, m_livestock, Farm::m_OurManager, m_totalFUdemand, m_totalFUdemandBefore, FarmManager::pm_data, tolp_Foobar, FarmManager::TranslateLivestockParametersCodes(), and CfgBool::value().

Referenced by NonAnimalFarm::findFodderDemand().

                                      {
     m_totalFUdemand=0;
     for(int i=0; i< (int) m_livestock.size(); i++){
         string str_FUuKey="FUuKey";
         TTypesOfAnimals index=m_livestock[i]->m_animalType;
         double FUuKey=m_OurManager->pm_data->Get_livestockParameter(tolp_Foobar*index + m_OurManager->TranslateLivestockParametersCodes(str_FUuKey)); //number of fodder units needed per one animal per year
         double number = m_livestock[i]->m_number;
 
         if(!cfg_UseBedriftsmodelFarmAreas.value()){ //almass farm areas - need to scale the livestock numbers; we don't even have to take integer...
             number *= m_area_scaling_factor;
         }
 
         if(number>0){
             double FUdemand=FUuKey*number;
             m_livestock[i]->m_FUdemand = FUdemand;
             m_totalFUdemand+=FUdemand;
         }
     }
     m_totalFUdemandBefore=m_totalFUdemand; //just to know afterwards the total demand
 }

void OptimisingFarm::findGrossMargin	(	CropOptimised *	a_crop,
		int	a_foobar,
		double	benefit
	)

protected

Determines the gross margin (CropOptimised::m_GM) for a given crop at a farm.

Function determining gross margin (CropOptimised::m_GM, i.e. profit per ha for a given crop; it might be positive only for non-fodder crops) and savings (CropOptimised::m_savings, savings from growing a fodder crop per ha, it equals zero for all non-fodder crops). [DKK]

Definition at line 5748 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, cfg_Price_Nt, crop_parameter(), DataForOptimisation::Get_fodder(), CropOptimised::m_BIFi, CropOptimised::m_BIHerb, CropOptimised::m_costs_ha, CropOptimised::m_cropType, CropOptimised::m_cropType_almass, m_farmType, CropOptimised::m_GM, CropOptimised::m_GM_Savings, CropOptimised::m_grooming, CropOptimised::m_hoeing, CropOptimised::m_income_ha, CropOptimised::m_nt, Farm::m_OurManager, CropOptimised::m_resp, CropOptimised::m_savings, CropOptimised::m_totalLoss, CropOptimised::m_weeding, FarmManager::pm_data, CfgFloat::value(), and CfgBool::value().

Referenced by optimizeCrops().

                                                                                         {
     int index = (cfg_OptimiseBedriftsmodelCrops.value())? (int) a_crop->m_cropType : (int) a_crop->m_cropType_almass;
 
     double priceFi = crop_parameter(index, "PriceFi");
     double priceHerb =crop_parameter(index, "PriceHerb");
     double priceG =crop_parameter(index, "PriceG");
     double priceH =crop_parameter(index, "PriceH");
     double priceW =crop_parameter(index, "PriceW");
     double priceLM =crop_parameter(index, "PriceLM");
     double subsidy =crop_parameter(index, "Subsidy");
 
     double resp = a_crop->m_resp;
     double BIHerb = a_crop->m_BIHerb;
     double BIFi = a_crop->m_BIFi;
     double grooming = a_crop->m_grooming;
     double hoeing = a_crop->m_hoeing;
     double weeding = a_crop->m_weeding;
     double totalLoss = a_crop->m_totalLoss;
     double nt = a_crop->m_nt;
     double priceNt = cfg_Price_Nt.value(); 
 
     double income_ha = benefit*resp*(1-totalLoss/100)+subsidy;
     double costs_ha = BIHerb*priceHerb + BIFi*priceFi + grooming*priceG + hoeing*priceH + weeding*priceW + nt*priceNt + priceLM;
     double profit = income_ha - costs_ha;
 
     a_crop->m_costs_ha = costs_ha;
     a_crop->m_GM_Savings = profit;
 
     //29.02.12
     int index1 = (cfg_OptimiseBedriftsmodelCrops.value())? a_foobar * m_farmType + a_crop->m_cropType : a_foobar * m_farmType + a_crop->m_cropType_almass;
     bool fodder = m_OurManager->pm_data->Get_fodder(index1);
     if (fodder){
         a_crop->m_income_ha = subsidy; //because fodder crops can't be sold
         a_crop->m_GM = subsidy-costs_ha; //because fodder crops can't be sold
         a_crop->m_savings = profit;
     }
     else{
         a_crop->m_income_ha = income_ha;
         a_crop->m_GM = profit;
         a_crop->m_savings = 0; //this is not a fodder crop!
     }
 }

void OptimisingFarm::findMWeedControl ( CropOptimised * a_crop )

protected

Determines the optimal mechanical weed control means (CropOptimised::m_grooming, CropOptimised::m_hoeing, CropOptimised::m_weeding) for a given crop at a farm.

Function determining optimal values of mechanical weed control means: grooming (CropOptimised::m_grooming), hoeing (CropOptimised::m_hoeing) and weeding (CropOptimised::m_weeding). All of them are functions of treatment frequency index (behandling indeks) for herbicides (CropOptimised::m_BIHerb).

Definition at line 5676 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, crop_parameter(), CropOptimised::m_BI, CropOptimised::m_BIFi, CropOptimised::m_BIHerb, CropOptimised::m_cropType, CropOptimised::m_cropType_almass, CropOptimised::m_grooming, CropOptimised::m_hoeing, CropOptimised::m_weeding, and CfgBool::value().

Referenced by optimizeCrops().

                                                            {
     int index = (cfg_OptimiseBedriftsmodelCrops.value())? (int) a_crop->m_cropType : (int) a_crop->m_cropType_almass;
 
     double betaG = crop_parameter(index, "BetaG");
     double betaH = crop_parameter(index, "BetaH");
     double betaW = crop_parameter(index, "BetaW");
     double alfaG = crop_parameter(index, "AlfaG");
     double alfaH = crop_parameter(index, "AlfaH");
     double alfaW = crop_parameter(index, "AlfaW");
     double BIHerb = a_crop->m_BIHerb;
 
     double grooming, hoeing, weeding =0;
     double g = betaG - BIHerb*alfaG;
     double h = betaH - BIHerb*alfaH;
     double w = betaW - BIHerb*alfaW;
     double BIHerbCorr = BIHerb;
 
     if(g <= 0){
         grooming=0;
         if(alfaG!=0) BIHerbCorr=betaG/alfaG;
     }
     else{grooming=g;}
     if(h <= 0){
         hoeing=0;
         if(betaH/alfaH < BIHerbCorr) BIHerbCorr=betaH/alfaH;
     }
     else{hoeing=h;}
     if(w <= 0){
         weeding=0;
         if(betaW/alfaW < BIHerbCorr) BIHerbCorr = betaW/alfaW;
     }
     else{weeding=w;}
 
 
     a_crop->m_grooming = grooming;
     a_crop->m_hoeing = hoeing;
     a_crop->m_weeding = weeding;
     if(BIHerbCorr < BIHerb){
         a_crop->m_BIHerb = BIHerbCorr;
         a_crop->m_BI = a_crop->m_BIHerb + a_crop->m_BIFi;
     }
 
 }

void OptimisingFarm::findNanim ( )

protected

Determines amount of animal fertilizer per ha (m_Nanim) at a farm.

Determines m_Nanim - amount of animal fertilizer per ha for a farm.

Definition at line 5188 of file farm.cpp.

References m_Nanim, m_totalArea, and m_totalNanim.

Referenced by FarmLevelCalculation().

                               {
     m_Nanim = m_totalNanim/m_totalArea;
  }

void OptimisingFarm::findResponse	(	CropOptimised *	a_crop,
		int	a_foobar
	)

protected

Determines the response (CropOptimised::m_resp) of a crop at a farm.

Function determining the response of a crop (yield per ha), CropOptimised::m_resp. It is a function of a total fertilizer (CropOptimised::m_n) applied for a crop at a given farm. [hkg/ha]

Definition at line 5554 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, DataForOptimisation::Get_alfa(), DataForOptimisation::Get_beta1(), DataForOptimisation::Get_beta2(), CropOptimised::m_cropType, CropOptimised::m_cropType_almass, CropOptimised::m_n, Farm::m_OurManager, CropOptimised::m_resp, m_soilType, FarmManager::pm_data, and CfgBool::value().

Referenced by optimizeCrops().

                                                                       {
 
     int index = (cfg_OptimiseBedriftsmodelCrops.value())? a_foobar * m_soilType + a_crop->m_cropType : a_foobar * m_soilType + a_crop->m_cropType_almass;
 
     double beta1=m_OurManager->pm_data->Get_beta1(index);
     double beta2=m_OurManager->pm_data->Get_beta2(index);
     double alfa=m_OurManager->pm_data->Get_alfa(index);
 
     double ntotal=a_crop->m_n;
     double resp1=alfa + beta1*ntotal + beta2*pow(ntotal,2);
     a_crop->m_resp = resp1;
 }

void OptimisingFarm::findTotalArea ( )

protected

Determines m_totalArea of a farm.

Function determining farm's total area. Depending on which area is to be used it either sums initial crop areas on a farm (to get area equal to area used in Bedriftsmodel) or deteremines area based on farm's fields size.

Definition at line 5147 of file farm.cpp.

References cfg_UseBedriftsmodelFarmAreas, Farm::GetAreaDouble(), m_area_scaling_factor, m_crops, m_totalArea, m_totalArea_original, and CfgBool::value().

Referenced by FarmLevelCalculation().

                                   {
     m_area_scaling_factor = 0;
     m_totalArea=0.;
     for (int i=0; i< (int) m_crops.size(); i++) {
         m_totalArea+=m_crops[i]->m_initialArea;
     }
     m_totalArea_original = m_totalArea;
 
     if(!cfg_UseBedriftsmodelFarmAreas.value()){ //almass farm areas used: just sum the fields area
         double area_copy = m_totalArea; //ha
         m_totalArea = GetAreaDouble()/10000; //change from sq m to ha
         m_area_scaling_factor = m_totalArea/area_copy;
     }
     //otherwise do nothing: total area = sum of initial crop areas (see the for loop)
 }

void OptimisingFarm::findTotalNanim ( )

protected

Determines total animal fertilizer (m_totalNanim) available at a farm.

Function determining farm's total animal fertilizer. Sums usable fertilizer from all types of livestock.

Definition at line 5166 of file farm.cpp.

References cfg_UseBedriftsmodelFarmAreas, DataForOptimisation::Get_livestockParameter(), m_area_scaling_factor, m_livestock, Farm::m_OurManager, m_totalNanim, FarmManager::pm_data, tolp_Foobar, FarmManager::TranslateLivestockParametersCodes(), and CfgBool::value().

Referenced by FarmLevelCalculation().

                                    {
      m_totalNanim = 0;
      for (int i=0; i< (int) m_livestock.size(); i++){
          string str_AUKey="AUKey";
          string str_Nusable="Nusable";
          TTypesOfAnimals index=m_livestock[i]->m_animalType;
          double AUKey = m_OurManager->pm_data->Get_livestockParameter(tolp_Foobar*index + m_OurManager->TranslateLivestockParametersCodes(str_AUKey)); //Number of animal units (AU, DE-dyreenheder) -> hkg N per year
          double Nusable = m_OurManager->pm_data->Get_livestockParameter(tolp_Foobar*index + m_OurManager->TranslateLivestockParametersCodes(str_Nusable)); // [%] Usable fertilizer from livestock
          double number = m_livestock[i]->m_number;
 
          if(!cfg_UseBedriftsmodelFarmAreas.value()){ //almass farm areas - need to scale the livestock numbers; we don't even have to take integer...
             number *= m_area_scaling_factor;
          }
 
          double NanimUsable = number*AUKey*Nusable*100; // [1*hkg/yr*1*100 = kg/yr] Usable fertilizer from livestock
          m_livestock[i]->m_NanimUsable = NanimUsable;
          m_totalNanim += NanimUsable;
      }
 }

void OptimisingFarm::findYieldLoss ( CropOptimised * a_crop )

protected

Determines the yield losses (CropOptimised::m_lossHerb, CropOptimised::m_lossFi, CropOptimised::m_totalLoss) for a given crop at a farm.

Function determining yield losses resulting from not using maximal amount of herbicides (CropOptimised::m_lossHerb), fungicides and insecticides (CropOptimised::m_lossFi) and a total yield loss, which is a sum of m_lossHerb and m_lossFi (CropOptimised::m_totalLoss). Losses are expressed as percentages of yield (take values from 0 to 100).

Definition at line 5723 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, crop_parameter(), CropOptimised::m_BIFi, CropOptimised::m_BIHerb, CropOptimised::m_cropType, CropOptimised::m_cropType_almass, CropOptimised::m_lossFi, CropOptimised::m_lossHerb, CropOptimised::m_totalLoss, and CfgBool::value().

Referenced by optimizeCrops().

                                                         {
     int index = (cfg_OptimiseBedriftsmodelCrops.value())? (int) a_crop->m_cropType : (int) a_crop->m_cropType_almass;
 
     double alfaFi = crop_parameter(index, "AlfaFi");
     double alfaHerb = crop_parameter(index, "AlfaHerb");
     double betaFi = crop_parameter(index, "BetaFi");
     double betaHerb = crop_parameter(index, "BetaHerb");
 
     double BIHerb=a_crop->m_BIHerb;
     double BIFi=a_crop->m_BIFi;
 
     double lossHerb = betaHerb - alfaHerb*BIHerb;
     a_crop->m_lossHerb = lossHerb;
 
     double lossFi = betaFi - alfaFi*BIFi;
     a_crop->m_lossFi = lossFi;
 
     double totalLoss = lossHerb + lossFi;// [%]
     a_crop->m_totalLoss = totalLoss;
 }

void OptimisingFarm::fixBI ( )

protected

Sets values of Treatment frequency indices (BI) for crops with fixed amount of pesticides (CropOptimised::m_BIHerb for FodderBeet and both CropOptimised::m_BIHerb and CropOptimised::m_BIFi for PotatoesIndustry and Potatoes).

Definition at line 5646 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, findCropByName(), findCropByName_almass(), CropOptimised::m_BI, CropOptimised::m_BIFi, CropOptimised::m_BIHerb, and CfgBool::value().

Referenced by optimizeCrops().

                           {
 
     if(cfg_OptimiseBedriftsmodelCrops.value()){ //b. crops
         CropOptimised *fodderBeet = findCropByName ("FodderBeet");
         CropOptimised *sugarBeet = findCropByName ("SugarBeet");
         CropOptimised *potato = findCropByName ("Potato");
         CropOptimised *potatoFood = findCropByName ("PotatoFood");
 
         fodderBeet->m_BIHerb = 2.28; //seems it's constant - in the results of Bedriftsmodel, but herbicide parameters are = zero!
         sugarBeet->m_BIHerb = 2.28;
         fodderBeet->m_BI = fodderBeet->m_BIFi + fodderBeet->m_BIHerb;
         sugarBeet->m_BI = sugarBeet->m_BIFi + sugarBeet->m_BIHerb;
 
         //potatoes - everything fixed
         potato->m_BIHerb = 1.41;    potato->m_BIFi = 9.28;  potato->m_BI = 10.69;
         potatoFood->m_BIHerb = 1.41;    potatoFood->m_BIFi = 9.28;  potatoFood->m_BI = 10.69;
     }
     else{ //almass crops
         CropOptimised *FodderBeet = findCropByName_almass ("FodderBeet");
         CropOptimised *PotatoesIndustry = findCropByName_almass ("PotatoesIndustry");
         CropOptimised *Potatoes = findCropByName_almass ("Potatoes");
 
         FodderBeet->m_BIHerb = 2.28; //the values have to be now like in the bedriftsmodel //modified probability
         FodderBeet->m_BI = FodderBeet->m_BIHerb + FodderBeet->m_BIFi;
         PotatoesIndustry->m_BIHerb = 1.41; PotatoesIndustry->m_BIFi = 9.28; PotatoesIndustry->m_BI = 10.69;
         Potatoes->m_BIHerb = 1.41; Potatoes->m_BIFi = 9.28; Potatoes->m_BI = 10.69;
     }
 
 }

bool OptimisingFarm::FungicideTreat	(	LE *	a_field,
		double	,
		int	a_days
	)

protectedvirtual

Carries out fungicide application. Saves information on each application for a given crop.

Reimplemented from Farm.

Definition at line 928 of file farmfuncs.cpp.

References VegElement::Add_no_fi_app(), DO_IT_PROB, EL_TRAMLINE_DECAYTIME, fungicide_treat, g_weather, LE::GetSignal(), Weather::GetWind(), LE_SIG_NO_FUNGICIDE, Weather::Raining(), LE::SetLastTreatment(), LE::SetTramlinesDecay(), LE::Trace(), and CfgBool::value().

 {
 
   if (0 >= a_days)
   {
     if ( ( ! a_field->GetSignal() & LE_SIG_NO_FUNGICIDE )) {
         a_field->Trace( fungicide_treat );
         a_field->SetLastTreatment( fungicide_treat );
         a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
         
         if(!cfg_OptimiseBedriftsmodelCrops.value()){
             Field * pf =  dynamic_cast<Field*>(a_field); 
             pf->Add_no_fi_app();
         }
     }
     return true;
   }
   else if ( (g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB)) {
     if ( ! (a_field->GetSignal() & LE_SIG_NO_FUNGICIDE) ) {
         a_field->Trace( fungicide_treat );
         a_field->SetLastTreatment( fungicide_treat );
         a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
         
         if(!cfg_OptimiseBedriftsmodelCrops.value()){
             Field * pf =  dynamic_cast<Field*>(a_field); 
             pf->Add_no_fi_app();
         }
     }   
     return true;
   }
   return false;
 }

double OptimisingFarm::Get_actual_aggregated_yield ( )

inline

Definition at line 1911 of file farm.h.

Referenced by ChooseDecisionMode().

1911 {return m_actual_aggregated_yield;};

OptimisingFarm::m_actual_aggregated_yield

double m_actual_aggregated_yield

Actual aggregated yield at a farm in a given year.

Definition: farm.h:1988

double OptimisingFarm::Get_actual_profit ( )

inline

Definition at line 1910 of file farm.h.

Referenced by ChooseDecisionMode().

1910 {return m_actual_profit;};

OptimisingFarm::m_actual_profit

double m_actual_profit

An actual profit realised at a farm in a given year.

Definition: farm.h:1975

int OptimisingFarm::Get_almass_no ( void )

inline

Definition at line 1896 of file farm.h.

Referenced by FarmManager::DumpFarmAreas(), FarmManager::FindNeighbours(), FarmManager::PrintDecModes_counts(), FarmManager::PrintNeighbours(), and FarmManager::PrintOutput().

1896 {return m_almass_no;}

OptimisingFarm::m_almass_no

int m_almass_no

Farm's almass number.

Definition: farm.h:2077

CropOptimised* OptimisingFarm::Get_crop ( int i )

inline

Definition at line 1897 of file farm.h.

Referenced by FarmManager::CropDistribution(), and FarmManager::PrintOutput().

1897 {return m_crops[i];}

OptimisingFarm::m_crops

vector< CropOptimised * > m_crops

Vector of pointers to all crops.

Definition: farm.h:2040

int OptimisingFarm::Get_cropsSize ( void )

inline

Definition at line 1898 of file farm.h.

Referenced by FarmManager::CropDistribution(), and FarmManager::PrintOutput().

1898 {return (int)m_crops.size();}

OptimisingFarm::m_crops

vector< CropOptimised * > m_crops

Vector of pointers to all crops.

Definition: farm.h:2040

int OptimisingFarm::Get_decision_mode_counters ( int index )

inline

Definition at line 1917 of file farm.h.

Referenced by FarmManager::PrintDecModes_counts().

1917 {return m_decision_mode_counters[index];};

OptimisingFarm::m_decision_mode_counters

vector< int > m_decision_mode_counters

Vector with counters for each decision mode. 0 - imitation, 1 - social comparison, 2 - repeat, 3 - deliberation.

Definition: farm.h:1971

int OptimisingFarm::Get_farmRealID ( void )

inline

Definition at line 1894 of file farm.h.

1894 {return m_farmRealID;}

OptimisingFarm::m_farmRealID

int m_farmRealID

Farm's real ID number.

Definition: farm.h:2073

TTypesOfFarmSize OptimisingFarm::Get_farmSize ( void )

inline

Definition at line 1893 of file farm.h.

Referenced by Find_neighbour_to_imitate().

1893 {return m_farmSize;}

OptimisingFarm::m_farmSize

TTypesOfFarmSize m_farmSize

Scale of the farm - business (size above 10 ha) or private (size below 10 ha).

Definition: farm.h:2071

TTypesOfOptFarms OptimisingFarm::Get_farmType ( void )

inline

Definition at line 1891 of file farm.h.

Referenced by FarmManager::Save_diff_farm_types_areas().

1891 {return m_farmType;}

OptimisingFarm::m_farmType

TTypesOfOptFarms m_farmType

Farm's type (cattle, pig, plant, other).

Definition: farm.h:2067

TTypeOfFarmerGoal OptimisingFarm::Get_main_goal ( )

inline

Definition at line 1915 of file farm.h.

Referenced by FarmManager::FarmManagement().

1915 {return m_main_goal;};

OptimisingFarm::m_main_goal

TTypeOfFarmerGoal m_main_goal

Farmer's main goal (determined by a farmer's type) .

Definition: farm.h:1960

OptimisingFarm* OptimisingFarm::Get_Neighbour ( int i )

inline

Definition at line 1907 of file farm.h.

Referenced by FarmManager::PrintNeighbours().

1907 {return m_neighbours[i];};

OptimisingFarm::m_neighbours

vector< OptimisingFarm * > m_neighbours

Vector of pointers to the farms considered neighbours (fulfilling the neighbourship condition) of a g...

Definition: farm.h:1965

int OptimisingFarm::Get_NeighboursSize ( void )

inline

Definition at line 1906 of file farm.h.

Referenced by FarmManager::PrintNeighbours().

1906 {return (int)m_neighbours.size();};

OptimisingFarm::m_neighbours

vector< OptimisingFarm * > m_neighbours

Vector of pointers to the farms considered neighbours (fulfilling the neighbourship condition) of a g...

Definition: farm.h:1965

vector<AlmassCrop> OptimisingFarm::Get_rotational_crops ( )

inline

Definition at line 1908 of file farm.h.

1908 {return m_rotational_crops;};

OptimisingFarm::m_rotational_crops

vector< AlmassCrop > m_rotational_crops

Vector of structs with almass type crops with positive areas in % (result of optimisation): includes ...

Definition: farm.h:2059

vector<AlmassCrop> OptimisingFarm::Get_rotational_crops_visible ( )

inline

Definition at line 1909 of file farm.h.

Referenced by ChooseDecisionMode().

1909 {return m_rotational_crops_visible;};

OptimisingFarm::m_rotational_crops_visible

vector< AlmassCrop > m_rotational_crops_visible

Stores a copy of m_rotational_crops from a previous year and is accessible to farmers who want to cop...

Definition: farm.h:2063

int OptimisingFarm::Get_soilSubType ( void )

inline

Definition at line 1895 of file farm.h.

1895 {return m_soilSubType;}

OptimisingFarm::m_soilSubType

int m_soilSubType

Farm's soil subtype. Defined only for cattle farms on sandy soil (0-bad, 1-good, 2-undefined).

Definition: farm.h:2075

TTypesOfSoils OptimisingFarm::Get_soilType ( void )

inline

Definition at line 1892 of file farm.h.

Referenced by Find_neighbour_to_imitate().

1892 {return m_soilType;}

OptimisingFarm::m_soilType

TTypesOfSoils m_soilType

Farm's soil type (sandy, clay, other).

Definition: farm.h:2069

int OptimisingFarm::GetFarmCentroidX ( )

inline

Definition at line 1912 of file farm.h.

Referenced by FarmManager::FindNeighbours().

1912 { return m_farm_centroidx; }

Farm::m_farm_centroidx

int m_farm_centroidx

Farm's centroid, value x. Equal to the average of the x centroid values of all farm's fields...

Definition: farm.h:861

int OptimisingFarm::GetFarmCentroidY ( )

inline

Definition at line 1913 of file farm.h.

Referenced by FarmManager::FindNeighbours().

1913 { return m_farm_centroidy; }

Farm::m_farm_centroidy

int m_farm_centroidy

Farm's centroid, value y. Equal to the average of the y centroid values of all farm's fields...

Definition: farm.h:863

void OptimisingFarm::HandleEvents ( void )

protectedvirtual

If there are events to carry out do this, and perhaps start a new crop.

Call the management plan for the current crop and it this return done=true starts the next management.

Sets the new index to the rotation.

Save the new veg type as the LE vegetation type

Reimplemented from Farm.

Definition at line 755 of file farm.cpp.

References LE::BumpRunNum(), cfg_OptimiseBedriftsmodelCrops, VegElement::Clean_CropDataStorage(), Calendar::Date(), g_date, g_farm_fixed_crop_enable, g_farm_fixed_crop_type, g_letype, g_msg, VegElement::Get_CropDataStorage(), VegElement::Get_taken(), LE::GetArea(), LE::GetRotIndex(), LE::GetRunNum(), LE::GetVegType(), LowPriPair< ELEMTYPE >::m_element, FarmEvent::m_field, LowPriPair< ELEMTYPE >::m_pri, PROG_START, LE::ResetTrace(), VegElement::Set_area_in_crop_data(), VegElement::Set_CropDataStorage(), VegElement::Set_taken(), VegElement::Set_tov_type(), LE::SetMgtLoopDetectDate(), LE::SetRotIndex(), LE::SetVegStore(), LE::SetVegType(), tov_Undefined, LE_TypeClass::TranslateVegTypes(), CfgInt::value(), CfgBool::value(), MapErrorMsg::Warn(), and WARN_FILE.

                                         {
   if ( m_queue.Empty() )
     return;
 
   LowPriPair < FarmEvent * > pair = m_queue.Bottom();
   FarmEvent * ev = pair.m_element;
   while ( pair.m_pri <= g_date->Date() ) {
     m_queue.Pop();
 
     if ( LeSwitch( ev ) ) {
       // This crop management plan has terminated.
 
       // First check for an infinite loop in the rotation scheme,
       // ie. a scenario where all crops decide not to run given
       // the date.
       CheckRotationManagementLoop( ev );
 
       // Outdate any remaining events for this field.
       ev->m_field->BumpRunNum();
 
       // Crop treatment done, select and initiate new crop if in rotation.
       TTypesOfVegetation new_veg = ev->m_field->GetVegType();
 
       if ( ev->m_field->GetRotIndex() >= 0 ) {
         int new_index = GetNextCropIndex( ev->m_field->GetRotIndex() );
         new_veg = m_rotation[ new_index ];
         // Running in fixed crop mode?
         if ( g_farm_fixed_crop_enable.value() ) {
           new_veg = g_letype->TranslateVegTypes( g_farm_fixed_crop_type.value() );
         }
         /*
         if ( g_farm_test_crop.value() ) {
           new_veg = g_letype->TranslateVegTypes( g_farm_test_crop_type.value() );
         }
         */
         ev->m_field->SetRotIndex( new_index );
         ev->m_field->SetVegType( new_veg, tov_Undefined );
         // ***CJT*** Testing removal 3/2/2015  ev->m_field->ForceGrowthTest(); 
       }
 
 
       //------------05.03.12 AM - tell a field the crop has changed - here the OptimisingFarm part---------------------------------------
       if(!cfg_OptimiseBedriftsmodelCrops.value()){ //don't do this if you simulate the bedriftsmodel (original farm optimization model) crops
           //switch the previous crop (if it is still there) to position 1 in an array m_CropDataStorage; put a new crop at position 0
           VegElement * pf =  dynamic_cast<VegElement*>(ev->m_field);
           if(pf->Get_taken(0)){ //there is a crop at position 0 - so need to copy it to position 1 and clear all values at position 0
               if(pf->Get_taken(1)){ //problem - we have 3rd crop when two previous crops were not calculated yet - it shouldn't happen!
                 char error_num[ 20 ];
                 sprintf( error_num, "%d", new_veg );
                 g_msg->Warn( WARN_FILE, "Farm::HandleEvents(): there is 3rd crop starting when 2 previous were not calculated yet, the 3rd crop is", error_num );
                 exit( 1 );
               }
               pf->Set_CropDataStorage(1, pf->Get_CropDataStorage(0)); //copy the content of a struct at position 0 of the m_CropDataStorage array to position 1
               pf->Set_taken(true, 1); //mark the struct at position 1 as taken by a crop
               pf->Clean_CropDataStorage(0); //clear struct at position 0
 
           }
           //now save the new crop at position zero - whether there was a crop here or not
           pf->Clean_CropDataStorage(0); //clear struct at position 0 //do it cause the previous crop's operations could have been saved here - if there was some time between accoutning and start of this new crop
           pf->Set_taken(true, 0); // the new crop is at position 0
           pf->Set_tov_type(new_veg, 0); //save the tov_type of a new crop
           pf->Set_area_in_crop_data(pf->GetArea());
       }
       //---------------------end 05.03.13----------------------------------------------------------------
 
 
       // Reset the event list for this field.
       ev->m_field->ResetTrace();
       // Reset event timeout counter.
       ev->m_field->SetVegStore( 0 );
 
       // The next bit simply determines the start date of the next crop in
       // the rotation and passes this to the start crop event.
       // The crop is responsible for raising an error if the next crop is
       // not possible or otherwise handling the problem
 
       // 19/5-2003: Note: This code was moved out into a dedicated
       // method of the Farm class, GetNextCropStartDate(), as precisely
       // the same piece of code needs to be run during initialization of
       // farm management.
       TTypesOfVegetation l_tov = new_veg;
       int l_nextcropstartdate = GetNextCropStartDate( ev->m_field, l_tov );
 
       // Create 'start' event for today and put it on the queue.
       AddNewEvent( new_veg, g_date->Date(), ev->m_field, PROG_START, ev->m_field->GetRunNum(),
            false, l_nextcropstartdate, false, l_tov );
 
       // Set starting date for rotation mgmt loop detection.
       ev->m_field->SetMgtLoopDetectDate( g_date->Date() );
     }
 
     delete ev;
 
     if ( m_queue.Empty() )
       return;
     pair = m_queue.Bottom();
     ev = pair.m_element;
   }
 }

bool OptimisingFarm::Harvest	(	LE *	a_field,
		double	a_user,
		int	a_days
	)

virtual

OptimisingFarm's virtual version of Farm::Harvest(). Saves information on biomass of a crop at harvest.

Reimplemented from Farm.

Definition at line 1487 of file farmfuncs.cpp.

References Calendar::Date(), DO_IT_PROB, EL_TRAMLINE_DECAYTIME, g_date, g_weather, LE::GetInsectPop(), Weather::GetRainPeriod(), LE::GetUnsprayedMarginPolyRef(), LE::GetVegBiomass(), VegElement::GetVegType(), harvest, harvest1, LE::InsectMortality(), LE::RecalculateBugsNStuff(), LE::ResetDigestability(), VegElement::Set_biomass_at_harvest(), VegElement::Set_harvested(), LE::SetGrowthPhase(), LE::SetInsectPop(), LE::SetLastTreatment(), LE::SetTramlinesDecay(), Landscape::SupplyLEPointer(), tov_Potatoes, tov_PotatoesIndustry, LE::Trace(), and CfgBool::value().

 {
 
   //5 days good weather before
   if ( (0 >= a_days) ||
        ((g_weather->GetRainPeriod(g_date->Date(),5)<0.1) && DoIt(DO_IT_PROB))) 
   {
 
     //05.03.13 need to get the info on biomass
     if(!cfg_OptimiseBedriftsmodelCrops.value()){
         Field * pf =  dynamic_cast<Field*>(a_field); //ok????? - maybe should be VegElement instead of field!
         if(pf->GetVegType()!=tov_Potatoes && pf->GetVegType()!=tov_PotatoesIndustry){ //do not save biomass for potatoes! 
             double biomass_at_harvest = a_field->GetVegBiomass();
             pf->Set_biomass_at_harvest(biomass_at_harvest, 0);  //sets the biomass of a current crop; the current crop is at the index 0
             pf->Set_harvested(); //mark this crop as harvested
         }
     }
     //05.03.13 end 
 
     a_field->Trace( harvest );
     a_field->SetLastTreatment( harvest );
     a_field->SetGrowthPhase( harvest1 );
     // Here we have to do a little skip to avoid too low insect populations after harvest, but a correct veg biomass
     a_field->InsectMortality( 0.4 );
     double insects=a_field->GetInsectPop();
     a_field->RecalculateBugsNStuff();
     a_field->SetInsectPop(insects);
     a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
     a_field->ResetDigestability();
     int pref=a_field->GetUnsprayedMarginPolyRef();
     if (pref!=-1){
       // Must have an unsprayed margin so need to pass the information on to it
       LE* um=g_landscape_p->SupplyLEPointer(pref);
       um->SetLastTreatment(harvest);
       um->SetGrowthPhase( harvest1 );
       um->InsectMortality( 0.4 );
       um->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
       um->ResetDigestability();
       um->RecalculateBugsNStuff();
     }
     return true;
   }
   return false;
 }

bool OptimisingFarm::HerbicideTreat	(	LE *	a_field,
		double	,
		int	a_days
	)

protectedvirtual

Carries out herbicide application. Saves information on each application for a given crop.

Reimplemented from Farm.

Definition at line 821 of file farmfuncs.cpp.

References VegElement::Add_no_herb_app(), DO_IT_PROB, EL_HERBICIDE_DELAYTIME, EL_TRAMLINE_DECAYTIME, g_weather, LE::GetSignal(), Weather::GetWind(), herbicide_treat, l_farm_herbicide_kills, LE_SIG_NO_HERBICIDE, Weather::Raining(), LE::ReduceWeedBiomass(), LE::SetHerbicideDelay(), LE::SetLastTreatment(), LE::SetTramlinesDecay(), LE::Trace(), and CfgBool::value().

 {
 
   if (0 >= a_days) // Must do this
   {
     if (((a_field->GetSignal() & LE_SIG_NO_HERBICIDE)==0 )) 
     {
         a_field->Trace( herbicide_treat );
         a_field->SetLastTreatment( herbicide_treat );
         if ( l_farm_herbicide_kills.value()) {
             a_field->ReduceWeedBiomass( 0.05 );
         }
         a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
         a_field->SetHerbicideDelay( EL_HERBICIDE_DELAYTIME );
         
         
         if(!cfg_OptimiseBedriftsmodelCrops.value()){
             Field * pf =  dynamic_cast<Field*>(a_field); 
             pf->Add_no_herb_app();
         }
 
      }
      return true;
   }
   else if ((g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB)) 
   {
     if ( !(a_field->GetSignal() & LE_SIG_NO_HERBICIDE) ) 
     {
         a_field->Trace( herbicide_treat );
         a_field->SetLastTreatment( herbicide_treat );
         if ( l_farm_herbicide_kills.value()) {
             a_field->ReduceWeedBiomass( 0.05 );
         }
         a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
         a_field->SetHerbicideDelay( EL_HERBICIDE_DELAYTIME );
         
         if(!cfg_OptimiseBedriftsmodelCrops.value()){
             Field * pf =  dynamic_cast<Field*>(a_field); 
             pf->Add_no_herb_app();
         }
     }
     return true;
   }
   return false;
 }

void OptimisingFarm::increaseCrops	(	vector< CropSort >	cropsToIncrease,
		double &	howMuchToIncrease
	)

protectedvirtual

Increases area of crops by a specified number.

Function increases area of one or more crops from the list given as a first argument.The total area added to the crops in the list is equal to the value of the second argument.

Reimplemented in AnimalFarm.

Definition at line 7377 of file farm.cpp.

Referenced by OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), NonAnimalFarm::checkWinterRotation1(), and AnimalFarm::determineFodderAreas().

                                                                                             {
     for(int i=0; howMuchToIncrease>0 && i<(int)cropsToIncrease.size(); i++){
         double area = cropsToIncrease[i].crop->m_areaPercent;
         double rotationMax = cropsToIncrease[i].crop->m_rotationMax;
         double rotMinCrop = cropsToIncrease[i].crop->m_rotationMin;
         if(area + howMuchToIncrease <= rotationMax){
             area += howMuchToIncrease; //finito
             howMuchToIncrease = 0;
         }
         else{
             howMuchToIncrease -= rotationMax-area;
             area = rotationMax;
         }
         cropsToIncrease[i].crop->m_areaPercent = area;
         cropsToIncrease[i].crop->m_areaVariable = area - rotMinCrop; 
     }
 }

void OptimisingFarm::Init ( ofstream * ap_output_file )

Function carrying out the initial calculations at a farm level (including the initial optimisation).

Definition at line 4817 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, createCropsLists(), FarmLevelCalculation(), m_crops_almass, Farm::m_PermCrops, Farm::m_rotation, Make_almass_crops_vector(), Make_rotational_crops(), Make_rotations(), OptimiseFarm(), Print_FarmVariables(), Print_rotations(), toc_Foobar, tov_OrchardCrop, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_SpringBarley, tov_Undefined, tov_YoungForest, Translate_crops_to_almass(), and CfgBool::value().

Referenced by FarmManager::InitFarms().

                                                   {
 
     int foobar = (cfg_OptimiseBedriftsmodelCrops.value())? (int)toc_Foobar : (int)tov_Undefined;
 
     FarmLevelCalculation(); //could stay in the constructor, but for clarity should be here
     createCropsLists(foobar);
     OptimiseFarm(foobar);
     Print_FarmVariables(ap_output_file);
 
     if(cfg_OptimiseBedriftsmodelCrops.value()){
         Translate_crops_to_almass();
         Make_rotations();
     }
     else{ //need to create almass crop vector and do all the things that are done otherwise in Make_rotations
         Make_almass_crops_vector();
         Make_rotational_crops();
         m_rotation.push_back(tov_SpringBarley); //put there one crop for the hidden year - m_rotation is used to initialize
 
         //deal with perm crops (copied from make rotations):
         int area_perm = 0; //sum of areas of permanent crops
         int no_perm=0;
         for(int i = 0; i < (int)m_crops_almass.size(); i++){
             TTypesOfVegetation tov = m_crops_almass[i].Tov;
 
             if (tov==tov_PermanentGrassGrazed || tov==tov_PermanentGrassTussocky || tov==tov_PermanentSetaside ||
                 tov==tov_PermanentGrassLowYield || tov==tov_YoungForest  || tov==tov_OrchardCrop) { //|| tov==tov_Orchard
                 int pct = (int)(m_crops_almass[i].Number + 0.5); //round a double to int
                 PermCropData pcd = {tov, pct};
                 m_PermCrops.push_back(pcd);
                 no_perm++;
                 area_perm += pct;
             }
         }
     }
     if(cfg_OptimiseBedriftsmodelCrops.value()){
         Print_rotations(ap_output_file);
     }
 
 }

void OptimisingFarm::Initialize ( FarmManager * a_pfm )

protected

Assigns to each farm its farm type, farm size, farm's real ID number, and soil type. It creates livestock and crops.

Definition at line 4710 of file farm.cpp.

Referenced by OptimisingFarm().

                                                   {
 
     //assign to each farm: farm type, farm size, real ID and soil type + soil subtype
     int size=(int)a_pfm->pm_data->m_farm_data.size();
     for(int i=0; i<size; i++){
         if(m_almass_no==a_pfm->pm_data->m_farm_data[i]->md_almass_no){
             m_farmType=a_pfm->pm_data->m_farm_data[i]->md_farmType;
             m_farmSize=a_pfm->pm_data->m_farm_data[i]->md_farmSize;
             m_farmRealID=a_pfm->pm_data->m_farm_data[i]->md_farmRealID;
             m_soilType=a_pfm->pm_data->m_farm_data[i]->md_soilType;
             m_soilSubType=a_pfm->pm_data->m_farm_data[i]->md_soilSubType;
         }
     }
 
     //create livestock
     for(int i=0; i<toa_Foobar; i++){
         int index=-1;
         int size=a_pfm->pm_data->Get_livestockNumbersSize();
         int j;
         for(j=0; j<size; j += (toa_Foobar+1)){
             if((a_pfm->pm_data->Get_livestockNumber(j))==m_almass_no){
                 index=j;
             }
         }
         //test for index!!
         if(index==-1){
             g_msg->Warn( WARN_BUG, "Farm's almass_no doesn't match any of the numbers within the livestock numbers vector", "" ); 
             exit(0);
         }
         int index2 = index + 1 + i;
         int number = a_pfm->pm_data->Get_livestockNumber(index2);
         if (number!=0){
             Livestock * p_lvs;
             TTypesOfAnimals livestock_type = a_pfm->pm_data->Get_livestockTypes(i);
             p_lvs = new Livestock(livestock_type, number);
             Set_Livestock(p_lvs);
         }
     }
 
     //create crops
     int no_crops = (cfg_OptimiseBedriftsmodelCrops.value())? toc_Foobar : a_pfm->pm_data->Get_noCrops(); //bedriftsmodel crops/almass crops
 
     for(int i=0; i<no_crops; i++){ //crop areas vector contains only the crops that are used, not all tov types!
         int index=-1;
         int size=a_pfm->pm_data->Get_cropAreasSize();
         int j;
         for(j=0; j<size; j+=(no_crops+1)){ //+1 becuase in the vector we store also farm numbers
             if((a_pfm->pm_data->Get_cropArea(j))==m_almass_no){
                 index=j;
                 break;
             }
         }
         //test for index!!
         if(index==-1){
             g_msg->Warn( WARN_BUG, "Farm's almass_no doesn't match any of the numbers within the crop areas vector", "" ); 
             exit(0);
         }
         int index2= index + 1 + i;
         double area=a_pfm->pm_data->Get_cropArea(index2);
 
         int foobar = (cfg_OptimiseBedriftsmodelCrops.value())? (int)toc_Foobar : (int)tov_Undefined; //bedriftsmodel crops/almass crops
 
         CropOptimised *p_crop;
         int index3 = -1;
         if (cfg_OptimiseBedriftsmodelCrops.value()){
             TTypesOfCrops crop_type = a_pfm->pm_data->Get_cropTypes(i);
             p_crop = new CropOptimised(crop_type, area);
             index3 = foobar*tofs_Foobar*tos_Foobar*m_farmType + foobar*tofs_Foobar*m_soilType + foobar*m_farmSize + crop_type; //crop_type is TTypesOfCrops
         }
         else{
              TTypesOfVegetation crop_type = a_pfm->pm_data->Get_cropTypes_almass(i);
              p_crop = new CropOptimised(crop_type, area);
              index3 = foobar*tofs_Foobar*tos_Foobar*m_farmType + foobar*tofs_Foobar*m_soilType + foobar*m_farmSize + crop_type; //crop_type is TTypesOfVegetation
         }
         //added 01.05: save the rot max ad min
         p_crop->m_rotationMax = m_OurManager->pm_data->Get_rotationMax(index3);
         p_crop->m_rotationMin = m_OurManager->pm_data->Get_rotationMin(index3);
 
         //add crop to the list of crops
         Set_Crop(p_crop);
     }
 }

void OptimisingFarm::InitiateManagement ( void )

protectedvirtual

Kicks off the farm's management.

It assignes permanent crops (if there are any) to fields. In case there are no rotational crops it checks if there are any fields that haven't been assigned any permanent crop. In case there are, it assignes to a field a first permanent crop from the list of this farm's permanent crops.

Reimplemented from Farm.

Definition at line 4647 of file farm.cpp.

References Farm::AssignPermanentCrop(), Farm::InitiateManagement(), Farm::m_fields, Farm::m_PermCrops, and tov_Undefined.

                                               {
 
     // First we need to assign the permanent crops if any.
     if (m_PermCrops.size()>0) {
         // We have something to do
         for (int i=0; i<(int)m_PermCrops.size(); i++) {
             AssignPermanentCrop(m_PermCrops[i].Tov, m_PermCrops[i].Pct);
         }
 
         //check if in case there are no rotational crops - all fields have been assigned a perm crop
         if(m_area_rot ==0) { //so there's  need to check
             for(int i=0; i<(int)m_fields.size(); i++){
                 if(m_fields[i]->GetRotIndex() != -4){ //there is a field that is not assigned a perm crop!
                     m_fields[i]->SetRotIndex(-4);
                     TTypesOfVegetation tov = m_PermCrops[0].Tov; //just take the first perm crop?
                     m_fields[i]->SetVegType(tov, tov_Undefined); //need a tov of one of the assigned perm crops
                 }
             }
         }
 
     }
 
     Farm::InitiateManagement();
 }

bool OptimisingFarm::InsecticideTreat	(	LE *	a_field,
		double	,
		int	a_days
	)

protectedvirtual

Carries out insecticide application. Saves information on each application for a given crop.

Reimplemented from Farm.

Definition at line 1006 of file farmfuncs.cpp.

References VegElement::Add_no_fi_app(), DO_IT_PROB, EL_TRAMLINE_DECAYTIME, g_weather, LE::GetSignal(), Weather::GetWind(), LE::Insecticide(), insecticide_treat, l_farm_insecticide_kills, LE_SIG_NO_INSECTICIDE, Weather::Raining(), LE::SetLastTreatment(), LE::SetTramlinesDecay(), LE::Trace(), and CfgBool::value().

 {
 
   if (0 >= a_days) 
   {
     if (( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE) )) 
     {
         // **CJT** Turn this code on to use the pesticide engine with insecticides
         //      g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
         //
         a_field->Trace( insecticide_treat );
         a_field->SetLastTreatment( insecticide_treat );
         if ( l_farm_insecticide_kills.value()) {
             a_field->Insecticide( 0.36 );
         }
         a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
         
         if(!cfg_OptimiseBedriftsmodelCrops.value()){
             Field * pf =  dynamic_cast<Field*>(a_field); 
             pf->Add_no_fi_app();
         }
 
     }   
     return true;
   }
   else if ( (g_weather->GetWind()<4.5) && (!g_weather->Raining()) && DoIt(DO_IT_PROB)) 
   {
     if ( ! (a_field->GetSignal() & LE_SIG_NO_INSECTICIDE )) {
         // **CJT** Turn this code on to use the pesticide engine with insecticides
         //      g_pest->DailyQueueAdd( a_field, l_pest_insecticide_amount.value());
         //
         a_field->Trace( insecticide_treat );
         a_field->SetLastTreatment( insecticide_treat );
         if ( l_farm_insecticide_kills.value()) {
             a_field->Insecticide( 0.36 );
         }
         a_field->SetTramlinesDecay( EL_TRAMLINE_DECAYTIME );
     
         if(!cfg_OptimiseBedriftsmodelCrops.value()){
             Field * pf =  dynamic_cast<Field*>(a_field); 
             pf->Add_no_fi_app();
         }
     }
     
     return true;
   }
   return false;
 }

void OptimisingFarm::Make_almass_crops_vector ( )

protected

Creates a vector storing crops with positive area. Used in ALMaSS crop mode.

The function goes throught the list of all crops and attach them to the m_crops_almass vector if the area resulting from optimisation is larger than zero.

Definition at line 7792 of file farm.cpp.

References m_crops, and m_crops_almass.

Referenced by ChooseDecisionMode(), and Init().

                                              {
     m_crops_almass.clear();
 
     for(int i = 0;  i < (int)m_crops.size(); i++){
         if(m_crops[i]->m_areaPercent > 0){
             TTypesOfVegetation tov = m_crops[i]->m_cropType_almass;
             AlmassCrop crop = { m_crops[i]->m_areaPercent, tov};
             m_crops_almass.push_back(crop);
         }
     }
 
 }

void OptimisingFarm::Make_rotational_crops ( )

protected

Creates a vector m_rotational_crops using the results of optimisation.

Definition at line 7808 of file farm.cpp.

References m_area_rot, m_crops_almass, m_rotational_crops, tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_OrchardCrop, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_SeedGrass1, tov_SeedGrass2, tov_SpringBarley, and tov_YoungForest.

Referenced by ChooseDecisionMode(), and Init().

                                           {
 
     //first deal with the probelmatic crops:CGG1 + CGG2 and SB, and SG1 + SG2
     double area_cgg=0;
     for(int i = 0; i < (int)m_crops_almass.size(); i++){
         if(m_crops_almass[i].Tov == tov_CloverGrassGrazed1){
             bool cg2=false;
             for(int j = 0; j < (int)m_crops_almass.size(); j++){
                 if(m_crops_almass[j].Tov == tov_CloverGrassGrazed2){
                     double pct = (m_crops_almass[i].Number + m_crops_almass[j].Number)/2; //take average
                     m_crops_almass[i].Number = pct;
                     m_crops_almass[j].Number = pct;
                     area_cgg = pct;
                     cg2=true;
                 }
             }
             if(!cg2){ //there is cgg1 but not cgg2
                 double pct = (m_crops_almass[i].Number)/2; //divide cgg1 area by two and save it in cgg1 and create cgg2
                 m_crops_almass[i].Number = pct;
                 area_cgg = pct;
                 AlmassCrop cgg2 = {pct, tov_CloverGrassGrazed2};
                 m_crops_almass.push_back(cgg2);
             }
             break;
         }
     }
 
     //cgg and sb
     bool sb=false;
     double new_area = area_cgg; //initialize with the current area of cgg - maybe it won't change
     for(int i = 0; i < (int)m_crops_almass.size(); i++){
         if(m_crops_almass[i].Tov == tov_SpringBarley){
             sb=true;
             double area_sb = m_crops_almass[i].Number;
             if(area_sb < area_cgg){ //problem
                 new_area = (area_sb + 2*area_cgg)/3;
                 m_crops_almass[i].Number = new_area;
             }
             break;
         }
     }
     if(!sb){ //there wasn't spring barley - need to add
         new_area = area_cgg*2/3;
         if(new_area >0){ //otherwise do not add sbarley
             AlmassCrop sb = {new_area, tov_SpringBarley};
             m_crops_almass.push_back(sb);
         }
     }
     //now find both cgg and change their areas
     for(int j = 0; j < (int)m_crops_almass.size(); j++){
         if(m_crops_almass[j].Tov == tov_CloverGrassGrazed1){
             m_crops_almass[j].Number = new_area;
         }
         if(m_crops_almass[j].Tov == tov_CloverGrassGrazed2){
             m_crops_almass[j].Number = new_area;
         }
     }
 
 
 
     //sg1 and sg2
     for(int i = 0; i < (int)m_crops_almass.size(); i++){
         if(m_crops_almass[i].Tov == tov_SeedGrass1){
             bool sg2=false;
             for(int j = 0; j < (int)m_crops_almass.size(); j++){
                 if(m_crops_almass[j].Tov == tov_SeedGrass2){
                     double pct = (m_crops_almass[i].Number + m_crops_almass[j].Number)/2; //take average
                     m_crops_almass[i].Number = pct;
                     m_crops_almass[j].Number = pct;
                     sg2=true;
                 }
             }
             if(!sg2){ //there is cgg1 but not cgg2
                 double pct = (m_crops_almass[i].Number)/2; //divide cgg1 area by two and save it in cgg1 and create cgg2
                 m_crops_almass[i].Number = pct;
                 AlmassCrop sg2 = {pct, tov_SeedGrass2};
                 m_crops_almass.push_back(sg2);
             }
             break;
         }
     }
 
     //first clear the current m_rotational_crops
     m_rotational_crops.clear();
 
     //then add rotational crops from the list of all crops - both rotational and permanent
     m_area_rot = 0;//sum of areas of rotational crops - need it for checking if there is any field without perm crops in case there are no rot. crops
     for(int i = 0; i < (int)m_crops_almass.size(); i++){
         TTypesOfVegetation tov = m_crops_almass[i].Tov;
 
         if (tov==tov_PermanentGrassGrazed || tov==tov_PermanentGrassTussocky || tov==tov_PermanentSetaside ||
             tov==tov_PermanentGrassLowYield || tov==tov_YoungForest  || tov==tov_OrchardCrop) { 
             //do nothing - just need rotational crops
         }
         else {
             double pct = m_crops_almass[i].Number;
             if(pct<0.5) pct+=0.5; //thanks to that such crop won't disappear! (won't have area=0 after rounding)
             AlmassCrop pcd = {pct, tov};
             m_rotational_crops.push_back(pcd);
             m_area_rot += pct;
         }
     }
 }

void OptimisingFarm::Make_rotations ( )

protected

Creates m_rotation. Not used in ALMaSS crop mode.

Used in the Bedriftsmodel crop mode. The function provides the functionality of the UserDefinedFarm's constructor:

it assigns true or false to the variable Farm::m_stockfarmer
creates a vector of permanent crops
creates a vector of rotational crops, m_rotation vector (size equal 100 or 0 in case there are only permanent crops) with a number of crop ocurrences corresponding to the optimised crop areas in percent of the total farm area.

Definition at line 7926 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, findCropByName(), findCropByName_almass(), g_msg, FarmManager::Get_lookup_table(), m_area_rot, CropOptimised::m_areaPercent, m_crops_almass, m_farmType, Farm::m_OurManager, Farm::m_PermCrops, Farm::m_rotation, m_rotational_crops, Farm::m_stockfarmer, toof_Cattle, toof_Pig, OptimisingFarm::MakeRotation::Tov, tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_FieldPeas, tov_FieldPeasSilage, tov_FodderBeet, tov_MaizeSilage, tov_OrchardCrop, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_Potatoes, tov_SeedGrass1, tov_SeedGrass2, tov_Setaside, tov_SpringBarley, tov_SpringRape, tov_Undefined, tov_WinterBarley, tov_WinterRape, tov_WinterWheat, tov_YoungForest, CfgBool::value(), MapErrorMsg::Warn(), and WARN_BUG.

Referenced by Init().

                                    {
     //1. STOCK FARM
     if (m_farmType==toof_Cattle || m_farmType==toof_Pig) m_stockfarmer = true;
     else m_stockfarmer = false;
 
     //2. INTENSITY - skip
 
     //3. PERMANENT vs ROTATIONAL CROPS
         //sort them and put into two vectors: m_PermCrops (member of Farm class, type: struct PermCropData) + local vector rotational_crops (type: struct AlmassCrop)
 
     int no_perm = 0;
     int no_rotational = 0;
     int area_perm = 0; //sum of areas of permanent crops
     m_area_rot = 0; //sum of areas of rotational crops
 
     for(int i = 0; i < (int)m_crops_almass.size(); i++){
         TTypesOfVegetation tov = m_crops_almass[i].Tov;
 
         if (tov==tov_PermanentGrassGrazed || tov==tov_PermanentGrassTussocky || tov==tov_PermanentSetaside ||
             tov==tov_PermanentGrassLowYield || tov==tov_YoungForest  || tov==tov_OrchardCrop) { 
             int pct = (int)(m_crops_almass[i].Number + 0.5); //round a double to int
             PermCropData pcd = {tov, pct};
             m_PermCrops.push_back(pcd);
             no_perm++;
             area_perm += pct;
         }
         else {
             double pct = m_crops_almass[i].Number;
             if(pct<0.5) pct+=0.5; //thanks to that such crop won't disappear! (won't have area=0 after rounding)
             AlmassCrop pcd = {pct, tov};
             m_rotational_crops.push_back(pcd);
             no_rotational++;
             m_area_rot += pct;
         }
     }
 
     //4. ROTATIONAL CROPS
 
     //first check if there are any rotational crops!
     if(m_rotational_crops.size()!=0){
 
         m_rotation.resize(100);
         vector<TTypesOfVegetation>all_crops; //vector the has a right proportion of each crop tov type
         vector<MakeRotation>rotation;
         rotation.resize(100);
 
         //scale the rotational crop areas to account for the area that is reserved for permanent crops
         //and
         //save scaled areas of SBarley and CGG1 to make a check in the next step
         int area_rot_int = (int)(m_area_rot + 0.5); //area in percent of rot crops - as an integer
         int SBarley_area=0;
         int CGG1_area=0;
 
         for(int i=0; i<(int)m_rotational_crops.size(); i++){
             double area = m_rotational_crops[i].Number;
             int area_scaled = (int)(100 * area / area_rot_int + 0.5);
             m_rotational_crops[i].Number = area_scaled;
             if(m_rotational_crops[i].Tov == tov_CloverGrassGrazed1) CGG1_area = (int) m_rotational_crops[i].Number; //scaled area
             if(m_rotational_crops[i].Tov == tov_SpringBarley) SBarley_area = (int) m_rotational_crops[i].Number; //(this is scaled area)
         }
 
         //check if we have enough spring barley for CGG1 and CGG2 (area CGG1 = area CGG2); if not - change the areas so that
         //SBarley = CGG1 = CGG2 area.
         if(SBarley_area < CGG1_area){ //problem
             if(SBarley_area == 0){ //there's no sbarley! - need to create
                 AlmassCrop sbarley  = {0, tov_SpringBarley};
                 m_rotational_crops.push_back(sbarley); //add sbarley
             }
             int new_area = (int)((CGG1_area * 2 + SBarley_area)/3 + 0.5); //= (CGG1 + CGG2 + SBarley)/3 ->and take integer
             for(int i=0; i<(int)m_rotational_crops.size(); i++){
                 if(m_rotational_crops[i].Tov == tov_CloverGrassGrazed1 || m_rotational_crops[i].Tov == tov_CloverGrassGrazed2 ||
                     m_rotational_crops[i].Tov == tov_SpringBarley){
                     m_rotational_crops[i].Number = new_area;
                 }
             }
         }
 
 
         //fill the all_crops vector with tov types -> in the right proportions
         for(int i = 0; i<(int)m_rotational_crops.size(); i++){
             int area = (int) m_rotational_crops[i].Number; //conversion to int - OK! - this is already int after the previous for loop
             for(int j = 0; j<area; j++){
                 all_crops.push_back(m_rotational_crops[i].Tov);
             }
         }//now the size of all_crops might NOT be 100! - so check and make it to be 100?
 
         //sort the all_crops vector and rearrange it so that the probability of two crops that cannot follow each other is minimised
         //so - the order of the for loops below matter!!!
         vector<TTypesOfVegetation>all_crops_helper; //vector helper
 
         for(int i = (int)all_crops.size()-1; i>=0; i--){ 
             if(all_crops[i] == tov_SpringBarley) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
 
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_CloverGrassGrazed1) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_CloverGrassGrazed2) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_FodderBeet) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_WinterRape) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_SpringRape) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_Potatoes) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_SeedGrass1) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = 0; i<(int)all_crops.size(); i++){
             if(all_crops[i] == tov_SeedGrass2) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_FieldPeas) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_FieldPeasSilage) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_WinterBarley) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_WinterWheat) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_Setaside) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
 
         for(int i = (int)all_crops.size()-1; i>=0; i--){
             if(all_crops[i] == tov_MaizeSilage) {
                 all_crops_helper.push_back(all_crops[i]);
                 all_crops.erase(all_crops.begin() + i);
             }
         }
 
         //now place the other - remaining crops (in the all_crops vector) in further positions of the helper vector
         for(int i = 0; i<(int)all_crops.size(); i++){
                 all_crops_helper.push_back(all_crops[i]);
         }
 
         //check if the size is 100 - correct if not
         if(all_crops_helper.size()!=100){
             if(all_crops_helper.size()>100){
                 for(int i = (int)all_crops_helper.size(); i>100; i--){
                     all_crops_helper.erase(all_crops_helper.end()-1); //just remove the last element
                 }
             }
             else{ //<100
                 for(int i = (int)all_crops_helper.size(); i<100; i++){
                     if(all_crops_helper[i-2] != tov_CloverGrassGrazed2) all_crops_helper.push_back(all_crops_helper[i-2]); //this way I duplicate the ending (max 2/4 last elements)
                     else all_crops_helper.push_back(tov_SpringBarley); //add spring barley
                 }
             }
         }
 
         //copy the helper to all_crops
         all_crops = all_crops_helper;
 
 
         //fill the rotation vector with tov_Undefined
         for(int i = 0; i<(int)rotation.size(); i++){
                 rotation[i].Tov = tov_Undefined;
         }
 
 
         // go through all_crops - should be 100...
 
         for(int i = 0; i < (int)all_crops.size(); i++){
 
             //find a place for the tov in the rotation vector:
             bool test=false;
             int count=0;
             TTypesOfVegetation crop_index = all_crops[i]; //current crop (tov) you want to place in a vector
 
             int step=no_rotational;
             int p=0; 
 
             for(int j = p;  count<101 && test==false; j=j+step){    
                 double sb_area = (cfg_OptimiseBedriftsmodelCrops.value())? findCropByName ("SBarley")->m_areaPercent : findCropByName_almass ("SpringBarley")->m_areaPercent;
                 if (crop_index == tov_SpringBarley && sb_area > (100/step)) step = (int)(100/sb_area + 0.5);
                 if(j>=100) {//without this we would always start out in the same position
                     if (crop_index == tov_SpringBarley) {p+=3; j=p;} //special case - sbarley, cgg1 and cgg2; has to be 3 - doesn't work with 4
                     else j=++p;
                 }
 
                 if(!(rotation[j].taken)){ //not taken - so check if it is allowed here - lookup
 
                     TTypesOfVegetation crop_before, crop_after;
 
                     crop_before = (j==0) ? rotation[99].Tov : rotation[j-1].Tov;
                     crop_after = (j==99) ? rotation[0].Tov : rotation[j+1].Tov;
 
                     int lookup_before = m_OurManager->Get_lookup_table(crop_before * (tov_Undefined+1) + crop_index); //check with a preceeding crop; tov_undef+1 - because this tov_undef is included in the lookup table
                     int lookup_after = m_OurManager->Get_lookup_table(crop_index * (tov_Undefined+1) + crop_after); //check with a following crop
 
                     if(lookup_before==-1 || lookup_after==-1){ //issue a warning: wrong index...
                         char index[ 20 ];
                         sprintf( index, "%d", crop_index);
                         g_msg->Warn( WARN_BUG, "OptimisingFarm::Make_rotations(): Error (possibly caused by a new tov type that is not incuded in the crops_lookup table) in reading the lookup table; tov type that should not appear: ", index );
                         exit( 1 );
                     }
 
                     if(lookup_before==1 && lookup_after==1){
                         rotation[j].Tov = all_crops[i]; //same as crop_index
                         rotation[j].taken = true;
                         test=true;
                     }
                     else count++; //did not succeed in placing the crop, so increase the count
                 }
                 else{
                     count++; //did not succeed in placing the crop, so increase the count
                 }
 
             } //inner for loop: searching for a place for a given crop
 
             if(test==false){ //there is no place that does not break the lookup table rules
 
                 //so try to go through the whole rotation and find a place where the current crop fits
 
                 for(int r=0; r<(int)rotation.size() && test==false; r++){
 
                     TTypesOfVegetation crop_before, crop_after;
 
                     crop_before = rotation[r].Tov; 
                     crop_after = (r==99) ? rotation[0].Tov : rotation[r+1].Tov;
                     int lookup_before = m_OurManager->Get_lookup_table(crop_before * (tov_Undefined+1) + crop_index); //check with a preceeding crop; tov_undef+1 - because this tov_undef is included in the lookup table
                     int lookup_after = m_OurManager->Get_lookup_table(crop_index * (tov_Undefined+1) + crop_after); //check with a following crop
 
                     if(lookup_before==1 && lookup_after==1){
                         MakeRotation crop = {true, all_crops[i]};
                         rotation.insert(rotation.begin() + r+1, crop); //->insert before element r+1
                         test=true;
 
                         //need to remove 1 element of the rotation! as 1 additional was just inserted
                         //but this might cause troubles: two already placed elements might become incompatible...
 
                         for(int p=(int)rotation.size()-1; p>=0; p--){//start at the end - more efficient, as here should be empty elements
                             if(rotation[p].Tov == tov_Undefined){
                                 rotation.erase(rotation.begin() + p);
                                 //check if the 'new neighbours' can be next to each other
                                 crop_before = (p==0) ? rotation[99].Tov : rotation[p-1].Tov; 
                                 crop_after = (p==100) ? rotation[0].Tov : rotation[p].Tov; //100 because the index is p
                                 int crop_after_position = (p==100) ? 0 : p;
 
                                 int lookup_before = m_OurManager->Get_lookup_table(crop_before * (tov_Undefined+1) + crop_after); //check with a preceeding crop; tov_undef+1 - because this tov_undef is included in the lookup table
 
                                 TTypesOfVegetation crop_before1, crop_after1, crop_before2;
                                 crop_before2=tov_Undefined; //for the begininng
                                 int crop_before2_position;
                                 int count2=0;
 
                                 while(lookup_before!=1){ //need to move somewhere the crop_after
 
                                     //check if there is no correct rotation possible
                                     if(count2>100){ //problem: impossible to make a rotation
                                         //so switch some crop...to Spring Barley
                                         TTypesOfVegetation problem_crop = rotation[crop_before2_position].Tov;
                                         rotation[crop_before2_position].Tov = tov_SpringBarley; 
                                         //issue a message
                                         char index[ 20 ];
                                         sprintf( index, "%d", problem_crop);
                                         g_msg->Warn( WARN_BUG, "OptimisingFarm::Make_rotations(): The following crop was changed to spring barley: ", index );
                                         break; //break the if
                                     }
 
                                     crop_index = crop_after; //now crop_after is searching for a place
                                     bool test2=false;
                                     for(int t=0; t<(int)rotation.size() && test2==false; t++){
                                         crop_before1 = rotation[t].Tov; 
                                         crop_after1 = (t==99) ? rotation[0].Tov : rotation[t+1].Tov;
                                         int lookup_before1 = m_OurManager->Get_lookup_table(crop_before1 * (tov_Undefined+1) + crop_index); //check with a preceeding crop; tov_undef+1 - because this tov_undef is included in the lookup table
                                         int lookup_after1 = m_OurManager->Get_lookup_table(crop_index * (tov_Undefined+1) + crop_after1); //check with a following crop
 
                                         if(lookup_before1==1 && lookup_after1==1){
                                             //check for indefinite loop
 
                                             bool skip=true;
                                             for(int s=crop_after_position; s!=t+1; s++){ //check locations between;
                                                 if(s==100) s=0;
                                                 TTypesOfVegetation crop = rotation[s].Tov;
                                                 int lookup = m_OurManager->Get_lookup_table(crop_before2 * (tov_Undefined+1) + crop);
                                                 if( lookup == 1){
                                                     skip = false;
                                                     break; //there is a different crop that the one that we removed (crop_index) - so there shouldnt be an infinite loop
                                                 }
                                             }
 
                                             if(!skip){
 
                                                 MakeRotation crop = {true, crop_index};
                                                 rotation.insert(rotation.begin() + t+1, crop);
                                                 //now the crop to be removed can be at the same or changed position, depending on where we inserted the crop
 
                                                 if(t+1 > crop_after_position){ //OK
                                                     rotation.erase(rotation.begin() + crop_after_position); //remove the crop that was just placed in a new position-from the old one
                                                     crop_before2 = (crop_after_position==0) ? rotation[99].Tov : rotation[crop_after_position-1].Tov;
                                                     crop_before2_position = (crop_after_position==0) ? 99 : crop_after_position-1;
                                                     crop_after = (crop_after_position==99) ? rotation[0].Tov : rotation[crop_after_position].Tov; 
                                                     crop_after_position = (crop_after_position==99) ? 0 : crop_after_position;
                                                     lookup_before = m_OurManager->Get_lookup_table(crop_before2 * (tov_Undefined+1) + crop_after);
                                                 }
                                                 else{
                                                     rotation.erase(rotation.begin() + crop_after_position + 1); //can be 99+1 -ok, now the size is 101
                                                     crop_before2 = (crop_after_position==0) ? rotation[99].Tov : rotation[crop_after_position].Tov;
                                                     crop_before2_position = (crop_after_position==0) ? 99 : crop_after_position;
                                                     crop_after = (crop_after_position==99) ? rotation[0].Tov : rotation[crop_after_position+1].Tov; 
                                                     crop_after_position = (crop_after_position==99) ? 0 : crop_after_position+1;
                                                     lookup_before = m_OurManager->Get_lookup_table(crop_before2 * (tov_Undefined+1) + crop_after);
                                                 }
                                                 test2=true;
                                             }
 
                                         }
 
                                     }
                                     count2++;
                                 } //while
 
                                 break; //break the for (index p) loop, need to remove just one element
                             }//undefined removed
                         }//for:searching for an undef element to remove
                     }//if:found a place to put an element that doesnt fit in any empty space left
                 }//for: searching for a place for a problematic crop
 
                 if(test==false){ //we have a problem
                     char index[ 20 ];
                     sprintf( index, "%d", crop_index);
                     //sprintf( index, "%d", m_almass_no);
                     g_msg->Warn( WARN_BUG, "OptimisingFarm::Make_rotations(): The following tov type cannot be assigned a place in the rotation: ", index );
                     exit( 1 );
                 }
 
             }//there's no empty space that fits for the current crop
         }//outer for loop: searcin for an empty spae for a current crop
 
 
         //copy the tovs from rotation vector to the m_rotation vector
         for(int i=0; i<100; i++){
             m_rotation[i] = rotation[i].Tov;
         }
 
     }//if there are any rotational crops
 
 else{ //no rotational crops
     m_rotation.resize(0);
     }
 }

void OptimisingFarm::Match_crop_to_field ( LE * a_field )

Finds a crop to be grown on a given field next year.

The function chooses a crop to grow in a given filed after the management plan of the current crop is finished.

Creates a probability distribution of choosing rotational crops based on their planned areas (as percentages of a farm's area).
Draws a number from the distribution and identifies which crop the number refers to.
Checks if the crop is allowed to follow the current crop in a field, and if the difference between the field's area and crop's planned area is within acceptable range (to avoid growing too much of a given crop). If either of the conditions is not fulfilled, point 2 is repeated until a crop fulfilling both conditions is chosen. If this procedure fails in choosing a crop 20 times, the 2nd condition is released and the search is continued.
If there is no crop fulfilling even just the 1st condition, the farm vector m_rotational_crops_copy is restarted, so that it includes all rotational crops a farmer wants to plant this year, including those that might have already been planted on other field this year.
If there is still no crop that can follow a current crop, spring barley is grown (this situation happens when in the rotation there are only crops that can follow one specific crop, e.g. CloverGrassGrazed1 can follow only SpringBarley and CloverGrassGrazed2 can only follow CloverGrassGrazed1).
When a crop to be grown is found, the function switches the rotation index to point to the crop placed in m_rotation before the chosen crop.

Definition at line 8684 of file farm.cpp.

References cfg_Areas_Based_on_Distribution, g_msg, FarmManager::Get_lookup_table(), LE::GetArea(), Farm::GetArea(), LE::GetVegType(), m_almass_no, Farm::m_fields, Farm::m_OurManager, Farm::m_rotation, m_rotational_crops, m_rotational_crops_copy, LE::SetRotIndex(), tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_OrchardCrop, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_SeedGrass1, tov_SeedGrass2, tov_SpringBarley, tov_SpringRape, tov_Undefined, tov_WinterRape, tov_YoungForest, CfgBool::value(), MapErrorMsg::Warn(), WARN_BUG, and WARN_FILE.

Referenced by Crop::ChooseNextCrop().

                                                    {
 
     double field_size_pct = a_field->GetArea()/GetArea() * 100; //convert field size to pct of total arable farm area (a_rotational_crops will contain values of areas in %)
     TTypesOfVegetation current_crop =a_field->GetVegType();
     TTypesOfVegetation crop_to_grow = tov_Undefined;
 
     if(current_crop==tov_PermanentGrassGrazed || current_crop==tov_PermanentGrassTussocky || current_crop==tov_PermanentSetaside ||
             current_crop==tov_PermanentGrassLowYield || current_crop==tov_YoungForest  || current_crop==tov_OrchardCrop) {
 
                 crop_to_grow = current_crop; //and do not switch rot index - has to stay as it is to mark the field as perm
     }
     else{
 
         if((int)m_rotational_crops_copy.size()==0 ){ // in the 1st year it is empty since the choose dec. mode was not called yet!
             m_rotational_crops_copy = m_rotational_crops; //restart the copy - it is empty and we still need crops
             //debug
             if((int)m_rotational_crops_copy.size()==0){ //should not happen!
                 char index[ 20 ];
                 sprintf( index, "%d", m_almass_no);
                 g_msg->Warn( WARN_BUG, "OptimisingFarm::Match_crop_to_field(): rot crops vector is empty! Farm no: ", index );
                 exit( 1 );
             }
         }
 
         if (current_crop==tov_SeedGrass1){ 
             bool sg2=false;
             for(int i=0; i< (int)m_rotational_crops_copy.size(); i++){
                 TTypesOfVegetation crop = m_rotational_crops_copy[i].Tov;
                 if(crop==tov_SeedGrass2) sg2 = true;
             }
             if (!sg2){ //there is no seedgrass2 in the list of crops. Otherwise just go to the normal procedure of choosing crop
                 crop_to_grow = tov_SeedGrass2;
             }
         }
         if (current_crop==tov_CloverGrassGrazed1){
             bool cgg2=false;
             for(int i=0; i< (int)m_rotational_crops_copy.size(); i++){
                 TTypesOfVegetation crop = m_rotational_crops_copy[i].Tov;
                 if(crop==tov_CloverGrassGrazed2) cgg2 = true;
             }
             if (!cgg2){ //there is no tov_CloverGrassGrazed2 in the list of crops. Otherwise just go to the normal procedure of choosing crop
                 crop_to_grow = tov_CloverGrassGrazed2;
             }
         }
 
         if (current_crop!=tov_SpringBarley){ 
             bool other_crop_than_cgg = false;
             for(int i=0; i< (int)m_rotational_crops_copy.size(); i++){
                 TTypesOfVegetation crop = m_rotational_crops_copy[i].Tov;
                 if(crop!=tov_CloverGrassGrazed2 && crop!=tov_CloverGrassGrazed1){
                     other_crop_than_cgg = true;
                     break;
                 }
             }
             if (!other_crop_than_cgg){ //there is no other tov than CGG1 or CGG2 in the list of crops. So need to grow smth which will fit - SB.
                 crop_to_grow = tov_SpringBarley;
             }
         }
 
         bool Sb_inserted=false;
         if(crop_to_grow==tov_Undefined){ //if not, it is already CGG2 or SG
 
             //create the vector with numbers
             vector<int>probability_line;
             probability_line.push_back(0); //add the first element
             for(int i=0; i< (int)m_rotational_crops_copy.size(); i++){
                 if(m_rotational_crops_copy[i].Number<0.5) m_rotational_crops_copy[i].Number += 0.5; //just in case - to avoid having crops that disappeear
                 int area = (int)(m_rotational_crops_copy[i].Number + 0.5); //change to integer
                 probability_line.push_back(area + (int)probability_line[probability_line.size() - 1]); //add a number equal to the sum of the current last element and this crop's area
             }
 
             //pick an index of a crop
                 //see: http://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution
             std::random_device rd;
             std::mt19937 gen(rd());
             int last_number = probability_line[(int)probability_line.size() - 1]; //the last number
             distribution_type2 dis(0, last_number - 1);
             double crop_index = 0;
 
             double diff = 0;
             int index_j = 0;
             bool crop_found = false;
             for(int c = 0; !crop_found; c++){
                 crop_index = dis(gen);   //int from a range 0 - sum of crop areas in percent - only crops that haven't been grown yet - on their 'full' i.e. planned area
                 //which crop is it?
                 for(int j=0; j < (int)probability_line.size(); j++){
                     if(j==(int)probability_line.size()-1) { //unless j=0 smth's wrong: we didnt find this index
                         if(j==0){ //there are no crops left - prob. line contains just one element - 0.why?
                             char index[ 20 ];
                             sprintf( index, "%d", (int) crop_index);
                             g_msg->Warn( WARN_BUG, "OptimisingFarm::Match_crop_to_field(): no crops left, index drawn is ", index );
                             exit( 1 );
                         }
                         else{
                             char index[ 20 ];
                             sprintf( index, "%d", (int) crop_index);
                             g_msg->Warn( WARN_BUG, "OptimisingFarm::Match_crop_to_field(): index not found in the prob. line", index );
                             exit( 1 );
                         }
                     }
                     if(crop_index >= probability_line[j] && crop_index < probability_line[j+1]) { 
                         if(j >= (int)m_rotational_crops_copy.size()) { //problem
                             char index[ 20 ];
                             sprintf( index, "%d", j);
                             g_msg->Warn( WARN_BUG, "OptimisingFarm::Match_crop_to_field(): index out of a range", index );
                             exit( 1 );
                         }
                         crop_to_grow = m_rotational_crops_copy[j].Tov;
                         index_j = j;
                         break; //got the crop type
                     }
 
                 }
                 //make a check
                 int lookup_before = m_OurManager->Get_lookup_table(current_crop * (tov_Undefined+1) + crop_to_grow); //check with a preceeding crop; tov_undef+1 - because this tov_undef is included in the lookup table
                 if(lookup_before==-1){ //issue a warning: wrong index...
                     char index[ 20 ];
                     sprintf( index, "%d", current_crop);
                     g_msg->Warn( WARN_BUG, "OptimisingFarm::Match_crop_to_field(): Error (possibly caused by a new tov type that is not incuded in the crops_lookup table) in reading the lookup table; tov type that should not appear: ", index );
                     exit( 1 );
                 }
                 if(lookup_before==1){ //if so, make another check - but not if we tried already 20 times - then release this constraint
 
                     bool WRape_grown = false;
                     if(cfg_Areas_Based_on_Distribution.value()){ //then another check: spring rape cannot be grown if the farm grows winter rape within 1000 m (www.landbrugsinfo.dk)
                         if(crop_to_grow == tov_SpringRape){
                             for(int w=0; w<(int)m_fields.size(); w++){
                                 if(m_fields[w]->GetVegType() == tov_WinterRape) WRape_grown = true;
                             }
                         }
                     }
 
                     if(c<20){
                         diff = field_size_pct - m_rotational_crops_copy[index_j].Number;
                         if(diff <= 20 && !WRape_grown){ //diff in size smaller than 20 percent points - ok. Plus there is no winter rape around in case the chosen crop is SRape
                             crop_found=true;
                             break; //break the for - this crop is OK
                         }
                     }
                     else{
                         diff = field_size_pct - m_rotational_crops_copy[index_j].Number; 
                         if(!WRape_grown){ 
                             crop_found=true; //this crop must be accepted
                             break;
                         }
                     }
                 }
                 if(c==1000 && !crop_found){ //seems there's no crop that can follow the current one, so restart the crops instead and continue the search!  
                     m_rotational_crops_copy = m_rotational_crops; //restart - that's not enough - need a new prob line
                     probability_line.clear();
                     probability_line.push_back(0); //add the first element
                     for(int i=0; i< (int)m_rotational_crops_copy.size(); i++){
                         if(m_rotational_crops_copy[i].Number<0.5) m_rotational_crops_copy[i].Number += 0.5; //necessary to avoid having crop disappeeared 
                         int area = (int)(m_rotational_crops_copy[i].Number + 0.5); //change to integer
                         probability_line.push_back(area + (int)probability_line[probability_line.size() - 1]); //add a number equal to the sum of the current last element and this crop's area
                     }
 
                     last_number = probability_line[(int)probability_line.size() - 1]; //the last number
                     distribution_type2 dis(0, last_number - 1);
                 }
                 if(c>1500){ //seems there's no crop that can follow the current one - issue a warning; but now do this only after restarting
                     #ifdef _DEBUG
                         char index[ 20 ];
                         sprintf( index, "%d", current_crop);
                         g_msg->Warn( WARN_BUG, "OptimisingFarm::Match_crop_to_field(): There is no crop that can follow the current crop. Sbarley will be grown. The current crop is: ", index );
                     #endif
                     crop_to_grow=tov_SpringBarley;
                     Sb_inserted=true;
                     break;
                     //exit( 1 );
                 }
             }
 
             //crop found, so update the vector of crops
             if(!Sb_inserted){
                 if(diff < 0){ //crop area should be larger than this field's area
                     m_rotational_crops_copy[index_j].Number -= field_size_pct;
                 }
                 else{
                     if(m_rotational_crops_copy.size() <1){ //smth is wrong
                         char index[ 20 ];
                         sprintf( index, "%d", current_crop);
                         g_msg->Warn( WARN_BUG, "OptimisingFarm::Match_crop_to_field(): m_rotational_crops_copy is empty, the crop chosen is: ", index );
                         exit( 1 );
                     }
                     m_rotational_crops_copy.erase(m_rotational_crops_copy.begin() + index_j);
                 }
             }
         }
 
         //switch the rotational index:
 
             //1. find the chosen crop in the m_rotation
         int position_in_mrotation=-1;
         int size=(int)m_rotation.size();
 
         for(int c=0; c< (int)m_rotation.size(); c++){
             if(m_rotation[c] == crop_to_grow){
                 position_in_mrotation=c;
                 break;
             }
         }
 
         if(position_in_mrotation==-1){
             char error_num[ 20 ];
             sprintf( error_num, "%d", crop_to_grow );
             g_msg->Warn( WARN_FILE, "OptimisingFarm::Match_crop_to_field(): ""Unknown vegetation type:", error_num );
             exit( 1 );
         }
             //2. switch the rot index to a crop just before the chosen one 
         if(position_in_mrotation!=0){
             a_field->SetRotIndex(position_in_mrotation-1);
         }
         else{
             a_field->SetRotIndex(size-1);
         }
     }//current crop is a rotational crop
 }

void OptimisingFarm::OptimiseFarm ( int a_foobar )

protected

Carries out the whole farm optimisation.

Definition at line 5288 of file farm.cpp.

References assignFixed(), cfg_Price_FU, Check_if_area_100(), checkRestrictions(), determineAreas(), determineAreas_ha(), m_crops, m_farmSize, m_totalBI, m_totalBIFi, m_totalBIHerb, m_totalCosts, m_totalFUt, m_totalGrooming, m_totalHoeing, m_totalIncome, m_totalN, m_totalNt, m_totalProfit, m_totalWeeding, m_variableCrops, optimizeCrops(), randomizeCropList(), sortCrops(), sumMinAreas(), tocv_BI, tocv_BIFi, tocv_BIHerb, tocv_Costs, tocv_GM, tocv_Grooming, tocv_Hoeing, tocv_Income, tocv_N, tocv_Nt, tocv_Weeding, tofs_Business, total(), and CfgFloat::value().

Referenced by ChooseDecisionMode(), and Init().

                                              {
 
     optimizeCrops(a_foobar); 
     sortCrops(m_variableCrops, "GM" );//ORDER OPTIMISED CROPS WRT HIGHEST GM
     randomizeCropList(m_variableCrops, "GM"); //shuffles elements of the list with equal GMs
     assignFixed();
     sumMinAreas();
     determineAreas(a_foobar);
 
     if(m_farmSize == tofs_Business){ 
         checkRestrictions();
     }
 
     Check_if_area_100();
 
     determineAreas_ha(m_crops);
 
     m_totalN=total(tocv_N);
     m_totalNt=total(tocv_Nt); //total amount of Nt at a farm - summed for all crops
     m_totalBIHerb=total(tocv_BIHerb);
     m_totalBIFi=total(tocv_BIFi);
     m_totalBI=total(tocv_BI);
     m_totalGrooming=total(tocv_Grooming);
     m_totalHoeing=total(tocv_Hoeing);
     m_totalWeeding=total(tocv_Weeding);
     m_totalIncome=total(tocv_Income);
     m_totalCosts=total(tocv_Costs);
     if(m_totalFUt>0) m_totalProfit = total(tocv_GM) - m_totalFUt * cfg_Price_FU.value();
     else m_totalProfit = total(tocv_GM);
 }

void OptimisingFarm::optimizeCrops ( int a_foobar )

protected

Carries out crop optimisation at a farm.

Function carrying out the optimisation of each crop for a given farm. It contains functions determining the optimal amounts (per ha) of fertilizer (animal and purchased), pesticides and mechanical weed control as well as functions finding response (yield per ha), yield loss and gross margin (profitability) of each crop.

Definition at line 5319 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, cfg_Price_FU, cfg_Price_Oats, cfg_Price_SBarley, cfg_Price_SRape, cfg_Price_Triticale, cfg_Price_WBarley, cfg_Price_WRape, cfg_Price_WWheat, cfg_Sensitivity_analysis, findBIs(), findFertilizer(), findGrossMargin(), findMWeedControl(), findResponse(), findYieldLoss(), fixBI(), DataForOptimisation::Get_fodder(), DataForOptimisation::Get_FUKey(), DataForOptimisation::Get_sellingPrice(), CropOptimised::m_benefit, m_crops, m_farmType, Farm::m_OurManager, m_soilType, FarmManager::pm_data, toc_Oats, toc_WWheat, toof_Cattle, toof_Pig, tos_Foobar, tov_Oats, tov_SpringBarley, tov_SpringRape, tov_Triticale, tov_WinterBarley, tov_WinterRape, tov_WinterWheat, CfgFloat::value(), and CfgBool::value().

Referenced by OptimiseFarm().

                                               {
 
     for (int i=0; i< (int) m_crops.size(); i++){
 
         //1. define the benefit; for non-fodder crops it is simply a selling price ;
         double benefit;
         int crop_type=(cfg_OptimiseBedriftsmodelCrops.value())? (int)m_crops[i]->m_cropType : (int)m_crops[i]->m_cropType_almass;
         int index = a_foobar*m_farmType + crop_type;
         bool fodder = m_OurManager->pm_data->Get_fodder(index);
         if(fodder){
             double FUKey = m_OurManager->pm_data->Get_FUKey(index);
             benefit = FUKey * cfg_Price_FU.value(); 
         }
         else {benefit = m_OurManager->pm_data->Get_sellingPrice(a_foobar*tos_Foobar*m_farmType + a_foobar*m_soilType + crop_type);}
 
         CropOptimised * crop = m_crops[i]; //define a pointer which is passed in the functions below
 
         crop->m_benefit = benefit; //added 090114
 
         //for SA: modify the prices of crops included in the analysis
         if(cfg_Sensitivity_analysis.value()){ //modify the prices only if this is a sensitivity analysis/calibration run
             if(cfg_OptimiseBedriftsmodelCrops.value()){
                 if(crop_type==toc_Oats){ 
                     if(m_farmType != toof_Pig && m_farmType != toof_Cattle){//don't modify for these farms - for them the price is zero for this crop - becasue it is a fodder crop!
                         benefit = cfg_Price_Oats.value();
                     }
                 }
                 else if(crop_type==toc_WWheat){ //not fodder
                     benefit = cfg_Price_WWheat.value();
                 }
             }
             else{//almass crop set
                 if(crop_type==tov_SpringBarley){ //fodder for cattle and pig farms: price is zero if crop is a fodder crop. so changing price will affect only non-animal farms.
                     if(m_farmType != toof_Pig && m_farmType != toof_Cattle){//don't modify for these farms - for them the price is zero for this crop - becasue it is a fodder crop!
                         benefit = cfg_Price_SBarley.value();
                     }
                 }
                 else if(crop_type==tov_Oats){ //f for c and p
                     if(m_farmType != toof_Pig && m_farmType != toof_Cattle){//don't modify for these farms - for them the price is zero for this crop - becasue it is a fodder crop!
                         benefit = cfg_Price_Oats.value();
                     }
                 }
                 else if(crop_type==tov_WinterBarley){ //f for c and p
                     if(m_farmType != toof_Pig && m_farmType != toof_Cattle){//don't modify for these farms - for them the price is zero for this crop - becasue it is a fodder crop!
                         benefit = cfg_Price_WBarley.value();
                     }
                 }
                 else if(crop_type==tov_WinterWheat){ //not fodder
                     benefit = cfg_Price_WWheat.value();
                 }
                 else if(crop_type==tov_Triticale){ 
                     if(m_farmType != toof_Cattle){//don't modify for these farms - for them the price is zero for this crop - becasue it is a fodder crop!
                         benefit = cfg_Price_Triticale.value();
                     }
                 }
                 else if(crop_type==tov_WinterRape){ //not fodder
                     benefit = cfg_Price_WRape.value();
                 }
                 else if(crop_type==tov_SpringRape){ //not fodder
                     benefit = cfg_Price_SRape.value();
                 }
             }
         }
 
 
         //2. optimize the crop
         findFertilizer(crop, a_foobar, benefit);
         findResponse(crop, a_foobar);
         findBIs(crop, benefit);
         fixBI(); //added 22.03.13
         findMWeedControl(crop);
         findYieldLoss(crop);
         findGrossMargin(crop, a_foobar, benefit);
         
     }
 }

virtual void OptimisingFarm::preventCashCrops ( )

inlineprotectedvirtual

Prevents small cattle farms from growing cash crops and maize silage.

Reimplemented in OptimisingCattleFarm.

Definition at line 2150 of file farm.h.

Referenced by FarmLevelCalculation().

2150 {};

void OptimisingFarm::Print_FarmVariables ( ofstream * ap_output_file )

protected

Prints farm-level variables to a text file (one file for all farms).

Prints farm level variables into one file (FarmVariables.txt).

Definition at line 7568 of file farm.cpp.

References m_almass_no, m_main_goal, m_Nanim, m_totalArea, m_totalBI, m_totalBIFi, m_totalBIHerb, m_totalCosts, m_totalFUdemand, m_totalFUdemandBefore, m_totalFUgrown, m_totalFUt, m_totalGrooming, m_totalHoeing, m_totalIncome, m_totalN, m_totalNanim, m_totalNt, m_totalProfit, and m_totalWeeding.

Referenced by Init().

                                                                  {
     //print the almass farm number
     (*ap_output_file) << m_almass_no << '\t';
 
     //print the values
     (*ap_output_file) <<  m_main_goal << '\t' << m_totalArea << '\t' <<  m_totalIncome<<'\t'<<  m_totalCosts <<'\t'<<  m_totalProfit <<'\t';
     (*ap_output_file) <<  m_totalFUdemand <<'\t' <<  m_totalFUdemandBefore << '\t' <<  m_totalFUt <<'\t'<< m_totalFUgrown << '\t';
     (*ap_output_file) <<  m_Nanim <<'\t'<<  m_totalNanim <<'\t'<<  m_totalNt <<'\t'<<  m_totalN <<'\t';
     (*ap_output_file) <<  m_totalBI <<'\t'<<  m_totalBIHerb <<'\t'<<  m_totalBIFi <<'\t';
     (*ap_output_file) <<  m_totalGrooming <<'\t'<<  m_totalHoeing <<'\t'<<  m_totalWeeding <<'\t';
     (*ap_output_file) << endl;
 }

void OptimisingFarm::Print_rotations ( ofstream * ap_output_file )

protected

Prints the content of a farm's m_rotation. Not used in ALMaSS crop mode.

Prints the content of m_rotation vector into the FarmVariables text file.

Definition at line 7912 of file farm.cpp.

References Farm::m_rotation.

Referenced by Init().

                                                              {
     //print the almass farm number
     //(*ap_output_file) << m_almass_no << '\t';
 
     //print the content of the m_rotation vector
     for(int i=0; i<(int)m_rotation.size(); i++){
         TTypesOfVegetation crop = m_rotation[i];
         (*ap_output_file) << i << '\t' << crop << endl;
     }
     (*ap_output_file) << endl;
 }

double OptimisingFarm::Prob_multiplier ( )

virtual

Used when determining whether there should be a spraying event (i.e. pesticides application) or not. For yield maximizer it increases the chance of spraying event to account for his 'just in case' spraying.

Reimplemented from Farm.

Definition at line 4895 of file farm.cpp.

References cfg_Yield_max_pest_prob_multiplier, m_main_goal, tofg_yield, and CfgFloat::value().

                                        {
 
     if(m_main_goal==tofg_yield){    // || m_pest_goal == tofg_yield){ //in case we give farmers different goals - include also the pest_goal
         return cfg_Yield_max_pest_prob_multiplier.value(); 
     }
     else return 1; //for other farmer types
 }

void OptimisingFarm::randomizeCropList	(	vector< CropSort > &	listToRandomize,
		string	key
	)

protected

Swaps randomly elements of the list holding same values of the key (according to which the list was previosuly sorted).

Function randomly swaps elements of a sorted vector holding equal values of the key used for sorting. Uses a vector to carry out shuffling.

Definition at line 7334 of file farm.cpp.

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

Referenced by AnimalFarm::determineAreas(), and OptimiseFarm().

                                                                                    {
     std::vector<CropSort>helper; //to store and shuffle elements with an equal value of a key
     helper.push_back(listToRandomize[0]); //save the first element of the list in the helper list
 
     for(int i=1; i<(int)listToRandomize.size(); i++){ 
         double key_current, key_previous;
         if(key=="GM"){
             key_current=listToRandomize[i].crop->m_GM;
             key_previous=listToRandomize[i-1].crop->m_GM;
         }
         else if (key=="Savings"){
             key_current=listToRandomize[i].crop->m_savings;
             key_previous=listToRandomize[i-1].crop->m_savings;
         }
         else if(key=="GM_Savings"){
             key_current=listToRandomize[i].crop->m_GM_Savings;
             key_previous=listToRandomize[i-1].crop->m_GM_Savings;
         }
         else{
             key_current=key_previous=0;
             g_msg->Warn( WARN_FILE, "OptimisingFarm::randomizeCropList():" "Unknown sorting key identificator", key.c_str() );
             exit(0);
         }
 
         if(key_current==key_previous){
             helper.push_back(listToRandomize[i]);
         }
         else{
             std::random_shuffle(helper.begin(), helper.end());
             //insert the elements of the vector - back to the original list
             //assign the elements of the vector in the reverse order (that's easier then the
             //normal order). The last element of the list has index = i-1.
             for(int j=(int)helper.size()-1; j>=0; j--){
                 listToRandomize[i-1-j]=helper[j];
             }
             helper.clear(); //remove the elements...
             helper.push_back(listToRandomize[i]); //and 'start' a new vector with the current element
         }
     }
 }

void OptimisingFarm::Save_last_years_crops ( )

It saves the OptimisingFarm::m_rotational_crops in a vector m_rotational_crops_visible which is accessible for other farmers if they decide to copy it in the following year.

Definition at line 4995 of file farm.cpp.

References m_rotational_crops, and m_rotational_crops_visible.

Referenced by FarmManager::Save_last_years_crops_for_farms().

                                           {
 
     m_rotational_crops_visible = m_rotational_crops;
 
 }

void OptimisingFarm::Set_animals_no ( int a_number )

inline

Definition at line 1916 of file farm.h.

Referenced by FarmManager::FarmManagement().

1916 {animals_no = a_number;};

OptimisingFarm::animals_no

int animals_no

Holds the number of animals in a farm at a particular day in a year (depends on a species)...

Definition: farm.h:2011

void OptimisingFarm::Set_Crop ( CropOptimised * p_crop )

inline

Definition at line 1900 of file farm.h.

Referenced by Initialize().

1900 {m_crops.push_back(p_crop);};

OptimisingFarm::m_crops

vector< CropOptimised * > m_crops

Vector of pointers to all crops.

Definition: farm.h:2040

void OptimisingFarm::Set_Livestock ( Livestock * p_lvs )

inline

Definition at line 1899 of file farm.h.

Referenced by Initialize().

1899 {m_livestock.push_back(p_lvs);};

OptimisingFarm::m_livestock

vector< Livestock * > m_livestock

Vector of pointers to animals belonging to a farm.

Definition: farm.h:2038

void OptimisingFarm::Set_main_goal ( TTypeOfFarmerGoal a_goal )

inline

Definition at line 1914 of file farm.h.

1914 {m_main_goal = a_goal;};

OptimisingFarm::m_main_goal

TTypeOfFarmerGoal m_main_goal

Farmer's main goal (determined by a farmer's type) .

Definition: farm.h:1960

void OptimisingFarm::Set_Neighbour ( OptimisingFarm * farm )

inline

Definition at line 1905 of file farm.h.

Referenced by FarmManager::FindNeighbours().

1905 {m_neighbours.push_back(farm);};

OptimisingFarm::m_neighbours

vector< OptimisingFarm * > m_neighbours

Vector of pointers to the farms considered neighbours (fulfilling the neighbourship condition) of a g...

Definition: farm.h:1965

void OptimisingFarm::setRotationCropsAtMax ( )

protected

Increases area of winter rotation crops to their max. allowed area.

void OptimisingFarm::sortCrops	(	vector< CropSort > &	cropsToSort,
		string	sortingKey
	)

protected

Sorts structs of type CropSort.

Function for sorting crops using sortingKey as a criterion for sorting. First argument is a vector of structs containing a pointer to a crop and a key.

Definition at line 7311 of file farm.cpp.

Referenced by OptimisingCattleFarm::checkCattleRotation(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), NonAnimalFarm::checkWinterRotation1(), AnimalFarm::determineAreas(), and OptimiseFarm().

                                                                            {
     if(sortKey=="GM"){
         for (int i=0; i<(int)cropsToSort.size(); i++){//define the key to sorting
                 cropsToSort[i].key = cropsToSort[i].crop->m_GM;
             }
     }
     else if (sortKey=="Savings"){
         for (int i=0; i<(int)cropsToSort.size(); i++){//define the key to sorting
                 cropsToSort[i].key = cropsToSort[i].crop->m_savings;
             }
     }
     else {
         for (int i=0; i<(int)cropsToSort.size(); i++){//define the key to sorting
             cropsToSort[i].key = cropsToSort[i].crop->m_GM_Savings;
             }
     }
 
     sort(cropsToSort.begin(), cropsToSort.end(), reverseSort());
 }

bool OptimisingFarm::Spraying_fungins ( TTypesOfVegetation a_tov_type )

virtual

Returns true if a farmer decided to treat a given crop with fung- and insecticides.

Reimplemented from Farm.

Definition at line 4883 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, findCropByName_almass(), CropOptimised::m_BIFi, and CfgBool::value().

                                                                   {
 
     if(cfg_OptimiseBedriftsmodelCrops.value()){
         return true;
     }
     else{
         double BIfi = findCropByName_almass (a_tov_type)->m_BIFi;
         if (BIfi > 0) return true;
         else return false;
     }
 }

bool OptimisingFarm::Spraying_herbicides ( TTypesOfVegetation a_tov_type )

virtual

Returns true if a farmer decided to treat a given crop with herbicides.

Reimplemented from Farm.

Definition at line 4871 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, findCropByName_almass(), CropOptimised::m_BIHerb, and CfgBool::value().

                                                                       {
 
     if(cfg_OptimiseBedriftsmodelCrops.value()){
         return true;
     }
     else{
         double BIherb = findCropByName_almass (a_tov_type)->m_BIHerb;
         if (BIherb > 0) return true;
         else return false;
     }
 }

void OptimisingFarm::sumMinAreas ( )

protected

Adds minimum required areas of variable crops to the variable m_assigned.

The function adds the minimum required areas of variable crops to the variable m_assigned (which holds a share of the farm area excluded from the optimisation).

Definition at line 5817 of file farm.cpp.

References m_assigned, and m_variableCrops.

Referenced by OptimiseFarm().

                                 {
     for(int i=0; i<(int)m_variableCrops.size(); i++){
         double rotationMin = m_variableCrops[i].crop->m_rotationMin;
         m_assigned+=rotationMin; //the min area added to the area already assigned
     }
 }

double OptimisingFarm::total ( TTypesOfCropVariables variable_name )

protected

Function for determining total values per farm after initial optimisation.

Function for determining total values of crop variables per farm. Goes through the list of all crops. If an area of a crop is positive, it adds the area of this crop (in ha) multiplied by the value of a variable (per ha) to the total value per farm.

Definition at line 7500 of file farm.cpp.

References g_msg, m_crops, 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_BUG.

Referenced by OptimiseFarm().

                                                        {
     double totalAmount = 0;
     for (int i=0; i<(int)m_crops.size(); i++){
         double area_ha = m_crops[i]->m_area_ha;
         if(!area_ha==0){ //otherwise don't change totalAmount
            double value_per_ha;
            switch (a_var){
                 case tocv_AreaPercent:
                     value_per_ha = m_crops[i] ->m_areaPercent;
                     break;
                 case tocv_AreaHa:
                     value_per_ha = m_crops[i] ->m_area_ha;
                     break;
                 case tocv_N:
                     value_per_ha = m_crops[i] ->m_n;
                     break;
                 case tocv_Nt:
                     value_per_ha = m_crops[i] ->m_nt;
                     break;
                 case tocv_BIHerb:
                     value_per_ha = m_crops[i] ->m_BIHerb;
                     break;
                 case tocv_BIFi:
                     value_per_ha = m_crops[i] ->m_BIFi;
                     break;
                 case tocv_BI:
                     value_per_ha = m_crops[i] ->m_BI;
                     break;
                 case tocv_Grooming:
                     value_per_ha = m_crops[i] ->m_grooming;
                     break;
                 case tocv_Hoeing:
                     value_per_ha = m_crops[i] ->m_hoeing;
                     break;
                 case tocv_Weeding:
                     value_per_ha = m_crops[i] ->m_weeding;
                     break;
                 case tocv_TotalLoss:
                     value_per_ha = m_crops[i] ->m_totalLoss;
                     break;
                 case tocv_Response:
                     value_per_ha = m_crops[i] ->m_resp;
                     break;
                 case tocv_Income:
                     value_per_ha = m_crops[i] ->m_income_ha;
                     break;
                 case tocv_Costs:
                     value_per_ha = m_crops[i] ->m_costs_ha;
                     break;
                 case tocv_GM:
                     value_per_ha = m_crops[i] ->m_GM;
                     break;
                 case tocv_Savings:
                     value_per_ha = m_crops[i] ->m_savings;
                     break;
                 default:
                     g_msg->Warn( WARN_BUG, "OptimisingFarm::total(): ""Unknown crop variable type! ", "" );
                     exit( 1 );
                 }
                 totalAmount += value_per_ha * area_ha; //each crop's/(field's) optimal values per ha multiplied by acreage of a crop
            }
         }
         return totalAmount;
     }

void OptimisingFarm::Translate_crops_to_almass ( )

protected

Translates crops from Bedriftsmodel (original farm optimization model) to Almass crops. Used in Bedriftsmodel crop mode.

The function takes a vector m_crops as an input. It goes through all crops; for those with a positive areaPercent, it finds an equivalent in almass crops. The output is a vector of structs AlmassCrop (with 2 members: area in percent and tov, type of vegetation).

Definition at line 7598 of file farm.cpp.

References g_msg, m_crops, m_crops_almass, tov_Carrots, tov_CloverGrassGrazed1, tov_CloverGrassGrazed2, tov_FieldPeas, tov_FieldPeasSilage, tov_FodderBeet, tov_FodderGrass, tov_MaizeSilage, tov_Oats, tov_OrchardCrop, tov_PermanentGrassGrazed, tov_PermanentGrassLowYield, tov_PermanentGrassTussocky, tov_PermanentSetaside, tov_Potatoes, tov_PotatoesIndustry, tov_SeedGrass1, tov_SeedGrass2, tov_Setaside, tov_SpringBarley, tov_SpringBarleySilage, tov_SpringRape, tov_Triticale, tov_WinterBarley, tov_WinterRape, tov_WinterRye, tov_WinterWheat, tov_YoungForest, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by Init().

                                               {
     for(int i = 0;  i < (int)m_crops.size(); i++){
         if(m_crops[i]->m_areaPercent > 0){
             TTypesOfCrops toc = m_crops[i]->m_cropType; //Bedriftsmodel crop type
             TTypesOfVegetation tov;
 
             switch (toc) {
                 case 0: //toc_SBarley
                     tov =  tov_SpringBarley;
                     break;
                 case 1: //toc_Oats
                     tov = tov_Oats;
                     break;
                 case 2: //toc_OSCrops
                     tov = tov_SpringBarley; //spring wheat - no code for this crop
                     break;
                 case 3: //toc_WBarley
                     tov = tov_WinterBarley;
                     break;
                 case 4: //toc_WWheat
                     tov = tov_WinterWheat;
                     break;
                 case 5: //toc_WRye
                     tov = tov_WinterRye;
                     break;
                 case 6: //toc_Triticale
                     tov = tov_Triticale;
                     break;
                 case 7: //toc_SRape
                     tov = tov_SpringRape;
                     break;
                 case 8: //toc_WRape
                     tov = tov_WinterRape;
                     break;
                 case 9: //toc_OOilseed
                     tov = tov_WinterRape; 
                     break;
                 case 10: //toc_Peas
                     tov = tov_FieldPeas;
                     break;
                 case 11: //toc_OLSeed
                     tov = tov_FieldPeas;
                     break;
                 case 12: //toc_GrassSeed //TRANSLATES TO TWO ALMASS CROPS
                     tov = tov_SeedGrass1; //this translates to both tov_SeedGrass1 and tov_SeedGrass2; thus sg2 has to be considered in the rotation vector after the sg1; both get area percent = half of the original crop area percent
                     break;
                 case 13: //toc_Potato
                     tov = tov_PotatoesIndustry;
                     break;
                 case 14: //toc_PotatoFood
                     tov = tov_Potatoes; 
                     break;
                 case 15: //toc_SugarBeet
                     tov = tov_FodderBeet;
                     break;
                 case 16: //toc_GrassClover //TRANSLATES TO TWO ALMASS CROPS
                     tov = tov_CloverGrassGrazed1; // also tov_CloverGrassGrazed2; need to first aggregate with CloverGrz and then divide the sum by two!
                     break;
                 case 17: //toc_OLSeedCut
                     tov = tov_FieldPeasSilage; 
                     break;
                 case 18: //toc_SCerealSil
                     tov = tov_SpringBarleySilage;  //undersown
                     break;
                 case 19: //toc_PeasSil
                     tov = tov_FieldPeasSilage; 
                     break;
                 case 20: //toc_MaizeSil
                     tov = tov_MaizeSilage; //
                     break;
                 case 21: //toc_WCerealSil
                     tov = tov_SpringBarleySilage;
                     break;
                 case 22: //toc_SCerealG
                     tov = tov_SpringBarleySilage;
                     break;
                 case 23: //toc_PerGrassLow
                     tov = tov_PermanentGrassLowYield;
                     break;
                 case 24: //toc_PerGrassNorm
                     tov = tov_PermanentGrassGrazed;
                     break;
                 case 25: //toc_GrassEnv1
                     tov =  tov_PermanentGrassTussocky; // is aggregated with GrassEnv2
                     break;
                 case 26: //toc_GrassEnv2
                     tov = tov_PermanentGrassTussocky; // is aggregated with GrassEnv1 
                     break;
                 case 27: //toc_GrassRot
                     tov = tov_FodderGrass; 
                     break;
                 case 28: //toc_Setaside
                     tov = tov_Setaside;
                     break;
                 case 29: //toc_Uncult
                     tov = tov_PermanentSetaside; 
                     break;
                 case 30: //toc_OUncult
                     tov = tov_PermanentSetaside; 
                     break;
                 case 31: //toc_FodderBeet
                     tov = tov_FodderBeet;
                     break;
                 case 32: //toc_CloverGrz //TRANSLATES TO TWO ALMASS CROPS
                     tov = tov_CloverGrassGrazed1; // also tov_CloverGrassGrazed2; need to first aggregate with GrassClover and then divide the sum by two!
                     break;
                 case 33: //toc_Veg
                     tov = tov_Carrots;
                     break;
                 case 34: //toc_Fruit
                     tov = tov_OrchardCrop;
                     break;
                 case 35: //toc_FruitTree
                     tov = tov_OrchardCrop;
                     break;
                 case 36: //toc_OSpecCrops
                     tov = tov_Carrots; // could be also smth else
                     break;
                 case 37: //toc_ChrisTree
                     tov = tov_YoungForest;
                     break;
                 case 38: //toc_EnergyFor
                     tov = tov_YoungForest; // ideally should be willow
                     break;
                 case 39: //toc_Other
                     tov = tov_Carrots; // this also could be smth else
                     break;
                 default:
                     g_msg->Warn( WARN_BUG, "OptimisingFarm::Translate_crops_to_almass(): ""Unknown crop type! ", "" );
                     exit( 1 );
                 }
 
                 //try not separating fixed from variables crops
                 AlmassCrop crop = { m_crops[i]->m_areaPercent, tov};
                 m_crops_almass.push_back(crop);
 
         } //if
     }//for
 
     //aggregate the almass crops that are in >1 position in the  m_crops vector - so that they are listed only once
 
     vector<AlmassCrop>crops_almass_aggregated;
     int size = (int)m_crops_almass.size();
 
     for(int i = 0;  i < size; i++){
         TTypesOfVegetation tov1 = m_crops_almass[i].Tov;
         double summaryArea = m_crops_almass[i].Number; //initialize
         bool skip = false;
 
         for(int p = 0; p < i; p++){ //check if this tov was already aggregated (so check elements of the vector before this one)
             if(m_crops_almass[p].Tov == tov1){ //this tov is already aggregated, so skip i element
                 skip = true;
             }
         }
         if (!skip){
             for(int j = i+1; j < size; j++){ // start comparing with the crop following the one at position i
                 if(m_crops_almass[j].Tov == tov1){
                     summaryArea += m_crops_almass[j].Number; //add area to the summary area
                 }
             }
             AlmassCrop crop = {summaryArea, m_crops_almass[i].Tov, };
             crops_almass_aggregated.push_back(crop);
         }
     }
     m_crops_almass = crops_almass_aggregated; //save the aggregated crops in m_crops_almass vector
 
 
     //now deal with the crops that translate to more than one almass crop, i.e.:
     //1) GrassClover + CloverGrz = CGG1 + CGG2
     //2) GrassSeed = SG1 + SG2
 
 
     for(int i = 0; i < (int)m_crops_almass.size(); i++){
         if(m_crops_almass[i].Tov == tov_CloverGrassGrazed1){
             double pct = (m_crops_almass[i].Number)/2; //have to divide the area between CGG1 and CGG2
             m_crops_almass[i].Number = pct;
             AlmassCrop cgg2 = {pct, tov_CloverGrassGrazed2};
             m_crops_almass.push_back(cgg2);
         }
         if(m_crops_almass[i].Tov == tov_SeedGrass1){
             double pct = (m_crops_almass[i].Number)/2; //have to divide the area between SG1 and SG2
             m_crops_almass[i].Number = pct;
             AlmassCrop sg2 = {pct, tov_SeedGrass2};
             m_crops_almass.push_back(sg2);
         }
     }
 
 }

Member Data Documentation

int OptimisingFarm::animals_no

protected

Holds the number of animals in a farm at a particular day in a year (depends on a species).

Definition at line 2011 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

bool OptimisingFarm::force_deliberation

protected

If set to true, a farm must use deliberation as a decision strategy.

Definition at line 2009 of file farm.h.

Referenced by ActualProfit(), ChooseDecisionMode(), and OptimisingFarm().

double OptimisingFarm::m_actual_aggregated_yield

protected

Actual aggregated yield at a farm in a given year.

Sum of yield ratios (actual to expected yield) from all grown crops.

Definition at line 1988 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

double OptimisingFarm::m_actual_costs

protected

Actual costs at a farm in a given year.

Definition at line 1983 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

double OptimisingFarm::m_actual_income

protected

An actual income at a farm in a given year.

Definition at line 1979 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

double OptimisingFarm::m_actual_profit

protected

An actual profit realised at a farm in a given year.

Definition at line 1975 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

int OptimisingFarm::m_almass_no

protected

Farm's almass number.

Definition at line 2077 of file farm.h.

Referenced by ActualProfit(), Check_if_area_100(), OptimisingCattleFarm::checkCattleRotation(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), NonAnimalFarm::checkWinterRotation1(), AnimalFarm::determineMinFodder(), Find_neighbour_to_imitate(), Initialize(), Match_crop_to_field(), OptimisingFarm(), and Print_FarmVariables().

vector<double> OptimisingFarm::m_animals_numbers

protected

Vector for storing numbers of animals at a farm in previous years (3).

Definition at line 2007 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

double OptimisingFarm::m_area_rot

protected

Area assigned to rotational crops. [ha].

Definition at line 2123 of file farm.h.

Referenced by Make_rotational_crops(), and Make_rotations().

double OptimisingFarm::m_area_scaling_factor

protected

Factor used to scale areas of fixed crops and livestock numbers. Used to adjust these values to the farm's area used in ALMaSS crops mode.

Definition at line 2085 of file farm.h.

Referenced by assignFixed(), findFodderDemand(), findTotalArea(), and findTotalNanim().

double OptimisingFarm::m_assigned

protected

Variable holding a value of area already reserved for certain crops at a farm. [0-100%].

Definition at line 2099 of file farm.h.

Referenced by assignFixed(), determineAreas(), AnimalFarm::determineAreas(), and sumMinAreas().

double OptimisingFarm::m_certainty_level

protected

Farmer's certainty level.

Definition at line 1969 of file farm.h.

Referenced by ChooseDecisionMode().

vector<CropOptimised*> OptimisingFarm::m_crops

protected

Vector of pointers to all crops.

Definition at line 2040 of file farm.h.

Referenced by Check_if_area_100(), OptimisingPigFarm::check_WRape_WBarley(), AnimalFarm::createFodderCrops(), createVariableCrops(), findCropByName(), findCropByName_almass(), findTotalArea(), Make_almass_crops_vector(), OptimiseFarm(), optimizeCrops(), total(), and Translate_crops_to_almass().

vector<AlmassCrop> OptimisingFarm::m_crops_almass

protected

Vector of structs with almass type crops with positive areas in % (result of optimisation).

Definition at line 2057 of file farm.h.

Referenced by Init(), Make_almass_crops_vector(), Make_rotational_crops(), Make_rotations(), and Translate_crops_to_almass().

vector<int> OptimisingFarm::m_decision_mode_counters

protected

Vector with counters for each decision mode. 0 - imitation, 1 - social comparison, 2 - repeat, 3 - deliberation.

Definition at line 1971 of file farm.h.

Referenced by ChooseDecisionMode(), and OptimisingFarm().

double OptimisingFarm::m_exp_aggregated_yield

protected

Expected aggregated yield at a farm in a given year.

Equal to a number of fields with crops with positive CropOptimised::m_resp values.

Definition at line 1991 of file farm.h.

Referenced by ActualProfit().

double OptimisingFarm::m_exp_costs

protected

Expected costs at a farm in a given year.

Definition at line 1985 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

double OptimisingFarm::m_exp_income

protected

An expected farm's income at a farm in a given year.

Definition at line 1981 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

double OptimisingFarm::m_exp_profit

protected

An expected farm's profit for a given year.

Definition at line 1977 of file farm.h.

Referenced by ActualProfit(), and OptimisingFarm().

int OptimisingFarm::m_farmRealID

protected

Farm's real ID number.

Definition at line 2073 of file farm.h.

Referenced by Initialize().

TTypesOfFarmSize OptimisingFarm::m_farmSize

protected

Scale of the farm - business (size above 10 ha) or private (size below 10 ha).

Definition at line 2071 of file farm.h.

Referenced by Find_neighbour_to_imitate(), Initialize(), and OptimiseFarm().

TTypesOfOptFarms OptimisingFarm::m_farmType

protected

vector<CropOptimised*> OptimisingFarm::m_fixedCrops

protected

Vector of pointers to fixed crops.

Definition at line 2051 of file farm.h.

Referenced by assignFixed(), AnimalFarm::correctFodderDemand(), and createVariableCrops().

vector<CropOptimised*> OptimisingFarm::m_grownVariableCrops

protected

Vector of pointers to variable crops that are grown on area larger than areaMin (after determineAreas function was called).

Definition at line 2049 of file farm.h.

Referenced by determineAreas(), AnimalFarm::determineAreas(), AnimalFarm::determineFodderAreas(), and AnimalFarm::determineMinFodder().

vector<Livestock*> OptimisingFarm::m_livestock

protected

Vector of pointers to animals belonging to a farm.

Definition at line 2038 of file farm.h.

Referenced by findFodderDemand(), and findTotalNanim().

TTypeOfFarmerGoal OptimisingFarm::m_main_goal

protected

Farmer's main goal (determined by a farmer's type) .

Definition at line 1960 of file farm.h.

Referenced by ActualProfit(), ChooseDecisionMode(), findBIs(), findFertilizer(), OptimisingFarm(), Print_FarmVariables(), and Prob_multiplier().

double OptimisingFarm::m_Nanim

protected

Amount of animal fertilizer available at a farm per hectar. [kg/ha].

Definition at line 2089 of file farm.h.

Referenced by findFertilizer(), findNanim(), and Print_FarmVariables().

double OptimisingFarm::m_need_satisfaction_level

protected

Farmer's actual satisfaction level.

Definition at line 1967 of file farm.h.

Referenced by ActualProfit(), and ChooseDecisionMode().

vector<OptimisingFarm*> OptimisingFarm::m_neighbours

protected

Vector of pointers to the farms considered neighbours (fulfilling the neighbourship condition) of a given farm.

Definition at line 1965 of file farm.h.

Referenced by Find_neighbour_to_imitate().

vector<double> OptimisingFarm::m_previous_aggregated_yields

protected

Vector of aggregated yields from previous years.

Definition at line 2000 of file farm.h.

Referenced by ActualProfit().

vector<double> OptimisingFarm::m_previous_costs

protected

Vector of costs from previous years.

Definition at line 1998 of file farm.h.

Referenced by ActualProfit().

vector<double> OptimisingFarm::m_previous_incomes

protected

Vector of incomes from previous years.

Definition at line 1996 of file farm.h.

Referenced by ActualProfit().

vector<double> OptimisingFarm::m_previous_profits

protected

Vector of profits from previous years.

Definition at line 1994 of file farm.h.

Referenced by ActualProfit().

vector<double> OptimisingFarm::m_previous_satisfaction_levels

protected

Vector of satisfaction levels in five previous years.

Definition at line 2002 of file farm.h.

Referenced by ActualProfit(), and ChooseDecisionMode().

OptimisingFarm* OptimisingFarm::m_previously_imitated_neighbour

protected

The neighbouring farmer whose crops might be copied in imitation and social comparison decision modes.

Definition at line 2004 of file farm.h.

Referenced by ChooseDecisionMode(), Find_neighbour_to_imitate(), and OptimisingFarm().

vector<AlmassCrop> OptimisingFarm::m_rotational_crops

protected

Vector of structs with almass type crops with positive areas in % (result of optimisation): includes only rotational crops.

Definition at line 2059 of file farm.h.

Referenced by ChooseDecisionMode(), Make_rotational_crops(), Make_rotations(), Match_crop_to_field(), and Save_last_years_crops().

vector<AlmassCrop> OptimisingFarm::m_rotational_crops_copy

protected

A copy of m_rotational_crops used when matching crops to fields.

Definition at line 2061 of file farm.h.

Referenced by ChooseDecisionMode(), and Match_crop_to_field().

vector<AlmassCrop> OptimisingFarm::m_rotational_crops_visible

protected

Stores a copy of m_rotational_crops from a previous year and is accessible to farmers who want to copy this farm's crops (in imitation or social comparison decision mode).

Definition at line 2063 of file farm.h.

Referenced by Find_neighbour_to_imitate(), and Save_last_years_crops().

vector<CropSort> OptimisingFarm::m_rotationCrops

protected

Vector of structs containing pointers to (winter) rotation crops.

Definition at line 2053 of file farm.h.

Referenced by AnimalFarm::checkWinterRotation1(), and NonAnimalFarm::checkWinterRotation1().

int OptimisingFarm::m_soilSubType

protected

Farm's soil subtype. Defined only for cattle farms on sandy soil (0-bad, 1-good, 2-undefined).

Definition at line 2075 of file farm.h.

Referenced by Initialize(), and OptimisingCattleFarm::preventCashCrops().

TTypesOfSoils OptimisingFarm::m_soilType

protected

Farm's soil type (sandy, clay, other).

Definition at line 2069 of file farm.h.

Referenced by ActualProfit(), Find_neighbour_to_imitate(), findFertilizer(), findResponse(), Initialize(), optimizeCrops(), and OptimisingCattleFarm::preventCashCrops().

double OptimisingFarm::m_totalArea

protected

Total area of a farm. A sum of initial crop areas (if in bedriftsmodel, i.e. original farm optimization model, crops mode) or a sum of farm's fields area (if in ALMaSS crops mode). [ha].

Definition at line 2081 of file farm.h.

Referenced by assignFixed(), OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation(), OptimisingCattleFarm::checkCattleRotation_almass(), AnimalFarm::checkWinterRotation1(), AnimalFarm::correctFodderDemand(), AnimalFarm::decreaseCrops(), determineAreas_ha(), AnimalFarm::determineFodderAreas(), AnimalFarm::determineMinFodder(), findNanim(), findTotalArea(), AnimalFarm::increaseCrops(), Print_FarmVariables(), and OptimisingCattleFarm::setCattleCropsAtMin().

double OptimisingFarm::m_totalArea_original

protected

Total area of a farm as in bedriftsmodel, i.e. original farm optimization model. [ha].

Definition at line 2083 of file farm.h.

Referenced by findTotalArea(), and OptimisingCattleFarm::preventCashCrops().

double OptimisingFarm::m_totalBI

protected

Total amount of pesticides (sum of m_totalBIHerb and m_totalBIFi) which is planned to be applied at a farm. Expressed as a Treatment frequency index (behandling indeks, BI in Danish).

Definition at line 2109 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalBIFi

protected

Total amount of fung- and insecticides which is planned to be applied at a farm. Expressed as a Treatment frequency index (behandling indeks, BI in Danish).

Definition at line 2107 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalBIHerb

protected

Total amount of herbicides which is planned to be applied at a farm. Expressed as a Treatment frequency index (behandling indeks, BI in Danish).

Definition at line 2105 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalCosts

protected

Planned total costs of growing crops at a farm. [DKK].

Definition at line 2117 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalFUdemand

protected

Farm's total demand for fodder (it is covered by growing fodder crops and/or purchasing fodder and thus, at the end of a year it should not be positive). [fodder units]

Definition at line 2093 of file farm.h.

Referenced by ChooseDecisionMode(), AnimalFarm::correctFodderDemand(), AnimalFarm::determineFodderAreas(), AnimalFarm::determineMinFodder(), findFodderDemand(), NonAnimalFarm::findFodderDemand(), and Print_FarmVariables().

double OptimisingFarm::m_totalFUdemandBefore

protected

Farm's total demand for fodder. [fodder units]

Definition at line 2091 of file farm.h.

Referenced by ChooseDecisionMode(), findFodderDemand(), and Print_FarmVariables().

double OptimisingFarm::m_totalFUgrown

protected

Fodder grown, i.e. obtained from growing fodder crops. [fodder units].

Definition at line 2097 of file farm.h.

Referenced by OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation(), OptimisingCattleFarm::checkCattleRotation_almass(), AnimalFarm::checkWinterRotation1(), ChooseDecisionMode(), AnimalFarm::correctFodderDemand(), AnimalFarm::decreaseCrops(), AnimalFarm::determineFodderAreas(), AnimalFarm::determineMinFodder(), NonAnimalFarm::findFodderDemand(), AnimalFarm::increaseCrops(), Print_FarmVariables(), and OptimisingCattleFarm::setCattleCropsAtMin().

double OptimisingFarm::m_totalFUt

protected

Fodder from trade (has to be purchased). [fodder units].

Definition at line 2095 of file farm.h.

Referenced by OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation(), OptimisingCattleFarm::checkCattleRotation_almass(), AnimalFarm::checkWinterRotation1(), AnimalFarm::decreaseCrops(), AnimalFarm::determineFodderAreas(), NonAnimalFarm::findFodderDemand(), AnimalFarm::increaseCrops(), OptimiseFarm(), Print_FarmVariables(), and OptimisingCattleFarm::setCattleCropsAtMin().

double OptimisingFarm::m_totalGrooming

protected

Total grooming planned at a farm.

Definition at line 2111 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalHoeing

protected

Total hoeing planned at a farm.

Definition at line 2113 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalIncome

protected

Planned total income from growing crops at a farm. [DKK].

Definition at line 2119 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalN

protected

Total amount of fertilizer used at a farm. [kg].

Definition at line 2101 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalNanim

protected

Total animal fertilizer at a farm. A sum of Livestock::m_NanimUsable (from all types of livestock). [kg].

Definition at line 2087 of file farm.h.

Referenced by findNanim(), findTotalNanim(), and Print_FarmVariables().

double OptimisingFarm::m_totalNt

protected

Total amount of fertilizer purchased at a farm. [kg].

Definition at line 2103 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalProfit

protected

Planned total profit (= income - costs) at a farm. In case of animal farms costs of purchased fodder is subtracted from the profit. [DKK].

Definition at line 2121 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

double OptimisingFarm::m_totalWeeding

protected

Total manual weeding planned at a farm.

Definition at line 2115 of file farm.h.

Referenced by OptimiseFarm(), and Print_FarmVariables().

vector<CropSort> OptimisingFarm::m_variableCrops

protected

Vector of structs containing pointers to crops which are not fixed.

Definition at line 2042 of file farm.h.

Referenced by OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation(), OptimisingCattleFarm::checkCattleRotation_almass(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), NonAnimalFarm::checkWinterRotation1(), AnimalFarm::correctFodderDemand(), createVariableCrops(), determineAreas(), AnimalFarm::determineAreas(), OptimiseFarm(), and sumMinAreas().

vector<CropSort> OptimisingFarm::m_variableCrops2

protected

Vector of structs containing pointers to crops which are not fixed and: in case of the winter rotation restriction - exclude winter rotation crops, in case of the cattle rotation restriction - exclude the three crops that form the condition of the restriction and winter wheat.

Definition at line 2047 of file farm.h.

Referenced by OptimisingPigFarm::check_WRape_WBarley(), OptimisingCattleFarm::checkCattleRotation(), OptimisingCattleFarm::checkCattleRotation_almass(), AnimalFarm::checkWinterCrops(), NonAnimalFarm::checkWinterCrops(), AnimalFarm::checkWinterRotation1(), and NonAnimalFarm::checkWinterRotation1().

vector<CropSort> OptimisingFarm::m_winterCrops

protected

Vector of structs containing pointers to winter crops.

Definition at line 2055 of file farm.h.

Referenced by AnimalFarm::checkWinterCrops(), and NonAnimalFarm::checkWinterCrops().

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
D:/CJT/Repos/ALMaSS_all/Landscape/farmfuncs.cpp

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation