#include <farm.h>

Inheritance diagram for OptimisingCattleFarm:

Public Member Functions
	OptimisingCattleFarm (FarmManager *a_myfarmmanager, int a_No)

virtual	~OptimisingCattleFarm ()

Public Member Functions inherited from AnimalFarm
	AnimalFarm (FarmManager *a_myfarmmanager, int a_No)

virtual	~AnimalFarm ()

Public Member Functions inherited from OptimisingFarm
	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	checkRestrictions ()
	Checks if the restrictions are fulfilled and corrects crops' areas if necessary. More...

void	checkCattleRotation ()
	Checks if the cattle restriction is fulfilled - in the Bedriftsmodel (original farm optimization model) crop mode. More...

void	checkCattleRotation_almass ()
	Checks if the cattle restriction is fulfilled - in the ALMaSS crops mode. More...

void	setCattleCropsAtMin ()
	Decreases area of cattle crops to their min. required area. More...

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

Protected Member Functions inherited from AnimalFarm
virtual void	createCropsLists (int a_foobar)
	Creates lists of crops. More...

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

void	createFodderCrops (int a_foobar)
	Creates a list of pointers to all fodder crops. More...

void	findFodderCropSavings ()
	Determines the savings resulting from growing a fodder crop relative to purchasing fodder. More...

void	correctFodderDemand (int a_foobar)
	Determines how much fodder is produced from fixed crops and min. areas of variable crops. More...

void	determineFodderAreas (int a_foobar)
	Determines areas of fodder crops and corrects areas of non-fodder crops. More...

void	determineMinFodder (int a_foobar)
	Covers the min. required fodder production for animal farms. More...

virtual void	checkWinterRotation1 ()
	Animal farm version of the OptimisingFarm::checkWinterRotation1() function (accounts for fodder changes). More...

virtual void	checkWinterCrops ()
	Animal farm version of the checkWinterCrops() function (accounts for fodder changes). More...

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

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

Protected Member Functions inherited from OptimisingFarm
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...

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...

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...

void	determineAreas_ha (vector< CropOptimised * >crops)
	Determines areas of crops in ha. 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...

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
vector< CropSort >	m_cattleCrops
	Vector of crops used in checkCattleRotation. More...

vector< CropSort >	m_cattleCrops_almass
	Vector of crops used in checkCattleRotation_almass. More...

Protected Attributes inherited from AnimalFarm
CropOptimised *	m_fakeCrop
	Crop used to fill up area of a farm up to 100% in case its non-fodder crops do not sum to 100% in determineAreas. Later this crop is removed in the function determineFodderAreas. More...

bool	m_fakeCropTest
	Set to true if the fake crop is present after determineAreas function. More...

vector< CropSort >	m_fodderCrops
	List of pointers to variable (non-fixed) fodder crops. More...

double	m_totalFodderToProduce
	Fodder that has to be produced by a farm to fulfill the min. fodder production restriction. [fodder units]. More...

double	m_fodderToProduce
	Fodder that has to be produced to fulfill the min. fodder production restriction at the end of a year (should be zero). Accounts for fodder from fixed crops and from min. areas of variable crops. [fodder units]. More...

double	m_fodderToProduceBefore
	Fodder that has to be produced to fulfill the min. fodder production restriction at the beginning of a year. Accounts for fodder from fixed crops and from min. areas of variable crops. Should be zero at the end of a year. [fodder units]. More...

bool	cash_crops_allowed
	Sets to true if cash crops are allowed. True by default. More...

Protected Attributes inherited from OptimisingFarm
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

Subclass of the AnimalFarm.

Definition at line 2305 of file farm.h.

Constructor & Destructor Documentation

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

Definition at line 4807 of file farm.cpp.

4807 :AnimalFarm(a_myfarmmanager, a_No){

4808 }

AnimalFarm::AnimalFarm

AnimalFarm(FarmManager *a_myfarmmanager, int a_No)

Definition: farm.cpp:4793

virtual OptimisingCattleFarm::~OptimisingCattleFarm ( )

inlinevirtual

Definition at line 2308 of file farm.h.

2308 {};

Member Function Documentation

void OptimisingCattleFarm::checkCattleRotation ( )

protected

Checks if the cattle restriction is fulfilled - in the Bedriftsmodel (original farm optimization model) crop mode.

Used in the Bedriftsmodel crop mode. Function checking if the restriction for cattle farms on attachment of spring barley, clover-grass and grass seed is fulfilled. If not, it corrects crops' areas - if possible, reduces the area of grass clover and/or seed grass and increases area of other crops. The function first checks if it pays off to substitute one or two of the cattle crops (clovergrass and grass seed) with a variable crop other than Spring Barley. If yes, it decreases the area of one or two of the cattle crops. If the condition is not fulfilled yet, the function reduces the area of one or two of the cattle crops and adds a corresponding area to the Spring Barley. None of the three crops in the condition is fixed. Spring barley and grass-clover are fodder crops.

Definition at line 6576 of file farm.cpp.

References OptimisingFarm::decreaseCrops(), OptimisingFarm::findCropByName(), DataForOptimisation::Get_fodder(), DataForOptimisation::Get_FUKey(), OptimisingFarm::increaseCrops(), OptimisingFarm::m_almass_no, CropOptimised::m_areaPercent, OptimisingFarm::m_farmType, CropOptimised::m_GM_Savings, Farm::m_OurManager, CropOptimised::m_resp, CropOptimised::m_rotationMax, OptimisingFarm::m_totalArea, OptimisingFarm::m_totalFUgrown, OptimisingFarm::m_totalFUt, CropOptimised::m_totalLoss, OptimisingFarm::m_variableCrops, OptimisingFarm::m_variableCrops2, FarmManager::pm_data, OptimisingFarm::sortCrops(), toc_Foobar, and toc_SBarley.

                                                {
 //This function can be called only after fodder crops were assigned areas because two of them are fodder crops! So before assiging the fodder crops, their areas will be zero!
 
 
     CropOptimised *sBarley = findCropByName("SBarley"); //fodder
     CropOptimised *gClover = findCropByName("GrassClover"); //fodder
     CropOptimised *gSeed = findCropByName("GrassSeed");
 
     CropOptimised *wWheat = findCropByName("WWheat");
 
     double areaSBarley = sBarley->m_areaPercent;
     double areaGClover = gClover->m_areaPercent;
     double areaGSeed = gSeed->m_areaPercent;
 
     double diff = areaGClover + areaGSeed - areaSBarley;
 
     if(diff > 0){ //restriction is not fulfilled
 
         //1. Make a vector of (two) cattle crops and sort them from highest to lowest GM/Savings
         CropSort cs1 = {0., gClover}; //an object with a key for sorting and a pointer to crop
         CropSort cs2 = {0., gSeed};
         m_cattleCrops.push_back(cs1);
         m_cattleCrops.push_back(cs2);
 
         sortCrops(m_cattleCrops, "GM_Savings"); //sorting the two crops
 
         //2. Make a new list of variable crops - excluding all crops forming the condition
         m_variableCrops2 = m_variableCrops; //initiate the new list and remove all three crops:
         for(int s=(int)m_variableCrops2.size()-1; s>=0; s--){
             if(m_variableCrops2[s].crop==sBarley || m_variableCrops2[s].crop==gClover || m_variableCrops2[s].crop==gSeed || m_variableCrops2[s].crop==wWheat){ //14.02 - added winter wheat - do not increase it!maybe i should even add here all winter crops...
                 m_variableCrops2.erase(m_variableCrops2.begin() + s);
             }
         }
 
         //3. check if it pays off to substitute one of the two cattle crops with variable crops other than SBarley; if so - change the areas
         for(int i=(int)m_cattleCrops.size()-1; i>=0 && diff>0; i--){ //start with the worse one
             double areaCC = m_cattleCrops[i].crop->m_areaPercent; //don't know which of the two it is, so have to get the values this way
             double areaMinCC = m_cattleCrops[i].crop->m_rotationMin;
             double areaCCBefore = areaCC;
             if(areaCC > areaMinCC){
                 bool cCropAtMin = false;
                 for(int j=0; j<(int)m_variableCrops2.size() && cCropAtMin==false; j++){ //start with the best variable crop
                     double GM_SBarley = sBarley->m_GM_Savings; 
                     double GM_CC = m_cattleCrops[i].crop->m_GM_Savings; //in case it is a fodder crop - then it takes savings, as now, after findFodderCropSavings() - savings are saved under GM_Savings for fodder crops
                     double GM_var = m_variableCrops2[j].crop->m_GM_Savings;
                     if(GM_SBarley + GM_CC > 2*GM_var){
                         //yes: it doesn't pay off to remove this cattle crop; go to the next part of the cattle rot. function: increase SBarley, cut one of the cattle crops
                     }
                     else{
                         double areaVar = m_variableCrops2[j].crop->m_areaPercent;
                         double areaMaxVar = m_variableCrops2[j].crop->m_rotationMax;
                         double areaVarBefore = areaVar;
 
                         if(areaCC - areaMinCC >= diff){
                             if(areaMaxVar - areaVar >= diff){
                                 areaCC -= diff;
                                 areaVar += diff;
                                 diff = 0; //finished -> cattle rotation fulfilled
                                 cCropAtMin = true; //stop the inner loop!!!
                             }
                             else{
                                 diff -= (areaMaxVar - areaVar);
                                 areaCC -= (areaMaxVar - areaVar);
                                 areaVar = areaMaxVar; //go to the next var. crop (j++)
                             }
                         }
                         else{
                             if(areaMaxVar - areaVar >= areaCC - areaMinCC){
                                 diff -= areaCC - areaMinCC;
                                 areaVar += areaCC - areaMinCC;
                                 areaCC = areaMinCC;
                                 cCropAtMin = true; //stop the inner loop - take the next cattle crop(i--)
                             }
                             else{
                                 diff -= areaMaxVar - areaVar;
                                 areaCC -= areaMaxVar - areaVar;
                                 areaVar = areaMaxVar; //go to the next var crop (j++)
                             }
                         }
 
                         //save the areas
                         m_variableCrops2[j].crop->m_areaPercent = areaVar;
                         m_cattleCrops[i].crop->m_areaPercent = areaCC;
 
                         //correct fodder variables for the changes - both for cattle and var crop
 
                         if(areaVar > areaVarBefore){
                             int index = toc_Foobar*m_farmType + m_variableCrops[j].crop->m_cropType;
                             bool fodder = m_OurManager->pm_data->Get_fodder(index);
                             if(fodder){ //this is a fodder crop - so you need to buy less fodder - totalFUt
                                 double resp = m_variableCrops[j].crop->m_resp;
                                 double loss = m_variableCrops[j].crop->m_totalLoss;
                                 double FUKey = m_OurManager->pm_data->Get_FUKey(index);
                                 double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
                                 double changeFU = (areaVar - areaVarBefore) * m_totalArea/100 * FUha; //positive
                                 m_totalFUt -= changeFU;
                                 m_totalFUgrown += changeFU;
                             }
                         }
 
                         if(areaCC < areaCCBefore){
                             int index = toc_Foobar*m_farmType + m_cattleCrops[i].crop->m_cropType;
                             bool fodder = m_OurManager->pm_data->Get_fodder(index);
                             if(fodder){ //this is a fodder crop - so you need to buy less fodder - totalFUt
                                 double resp = m_cattleCrops[i].crop->m_resp;
                                 double loss = m_cattleCrops[i].crop->m_totalLoss;
                                 double FUKey = m_OurManager->pm_data->Get_FUKey(index);
                                 double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
                                 double changeFU = (areaCCBefore - areaCC) * m_totalArea/100 * FUha; //positive
                                 m_totalFUt += changeFU;
                                 m_totalFUgrown -= changeFU;
                             }
                         }
                     }
 
                 }//inner for
             }
             else{
                 //nothing - go to the next cattle crop; if there's no more - then the diff must be zero - so the loop will stop
             }
 
         }//outer for
 
         //4. Check if diff is still > 0 (after point 3.), if so - substitute some area of one of the cattle crops with SBarley
 
         if(diff>0){
 
             double areaSBarleyMax = sBarley->m_rotationMax;
             double SBarleyAvailableArea = areaSBarleyMax-areaSBarley;
             double areaSBarleyBefore = areaSBarley;
 
             double available = 0; //available to cut from GClover and GSeed
             for(int i=0; i<(int)m_cattleCrops.size(); i++){  //or simply: i<2
                 double areaMin = m_cattleCrops[i].crop->m_rotationMin;
                 double area = m_cattleCrops[i].crop->m_areaPercent;
                 available += (area - areaMin);
             }
 
             if(areaSBarley < areaSBarleyMax){ //Y1
                 if(SBarleyAvailableArea >= diff/2){ //Y2
                     if(available >= diff/2){ //Y 3.2
                         areaSBarley += diff/2; //increase Sbarley by diff/2
                         diff /= 2; //updating diff
                         decreaseCrops(m_cattleCrops, diff);//decrease the two crops by diff/2 (now=to diff)
                     }
 
                     else{ //N 3.2
                         areaSBarley += available; 
                         diff -= 2 * available;//update diff
                         setCattleCropsAtMin(); //decrease the two crops to min each (by available<diff/2),
 
                         if(SBarleyAvailableArea >= diff){//if possible:
                             areaSBarley += diff;//increase Sbarley by diff
                             decreaseCrops(m_variableCrops2, diff);//& decrease the worst (available) normal crop by diff
                         }
                         else{
                             //do as much as possible
                             double toDecrease = areaSBarleyMax - areaSBarley; //neccesary -area has changed
                             areaSBarley = areaSBarleyMax; //increase Sbarley to max
                             diff-=toDecrease; //update diff
                             decreaseCrops(m_variableCrops2, toDecrease);//decrease normal crops
                             //and throw an exception! restriction must be violated
                             ofstream ofile("Restrictions.txt",ios::app); //changed 06.06 out to app
                             ofile << m_almass_no << '\t' << "cattle restriction: broken after N 3.2" << endl;
                             ofile.close();
                         }
                     }
                 }
                 else{ //N2
                     //increase SBarley to max in both cases
                     if(available >= SBarleyAvailableArea){ //Y 3.1
                         areaSBarley = areaSBarleyMax; //increase Sbarley to max
                         diff -= 2 * SBarleyAvailableArea; //update diff
                         available -= SBarleyAvailableArea; //decrease by what you add in the next line
                         decreaseCrops(m_cattleCrops, SBarleyAvailableArea);//increase needed by
 
                         double diffBefore = diff;
                         if(available >= diff){
                             decreaseCrops(m_cattleCrops, diff);//decrease the two crops by diff
                             increaseCrops(m_variableCrops2, diffBefore);//increase normal crops by diff
                         }
                         else{
                             //do as much as possible
                             setCattleCropsAtMin();
                             diff -= available; //update diff
                             double toDecrease = available;
                             increaseCrops(m_variableCrops2, toDecrease); //add some normal crops!
                             //and throw exception - restriction must be violated!
                             ofstream ofile("Restrictions.txt",ios::out);
                             ofile << m_almass_no << '\t' << "cattle restriction: broken after Y 3.1" << endl;
                             ofile.close();
                         }
                     }
                     else{ //N 3.1 - restriction violated, but try to do as much as possible
                         areaSBarley += available; 
                         setCattleCropsAtMin(); 
                         diff -= 2 * available; //update diff
                         double toDecrease = areaSBarleyMax - areaSBarley; //here it is necessary! because the area has changed
                         areaSBarley = areaSBarleyMax;//
                         diff -= toDecrease; //update diff
                         decreaseCrops(m_variableCrops2, toDecrease);//add normal crops-but still-violation!
                         //AND !!! throw an exception - violation
                         ofstream ofile("Restrictions.txt",ios::out);
                         ofile << m_almass_no << '\t' << "cattle restriction: broken after N 3.1" << endl;
                         ofile.close();
                     }
                 }
 
                 sBarley->m_areaPercent = areaSBarley;
 
                 //this is a fodder crop - so you need to buy less fodder - totalFUt
                 double resp = sBarley->m_resp;
                 double loss = sBarley->m_totalLoss;
                 double FUKey = m_OurManager->pm_data->Get_FUKey (toc_SBarley);
                 double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
                 double changeFU = (areaSBarley - areaSBarleyBefore) * m_totalArea/100 * FUha; //positive
                 m_totalFUt -= changeFU;
                 m_totalFUgrown += changeFU;
             }
 
             else{ // N 1
                  if(available >= diff){
                      double diffBefore = diff;
                      decreaseCrops(m_cattleCrops, diff); //cover the diff
                      increaseCrops(m_variableCrops2, diffBefore); //increase some normal crops
                  }
                  else{//restr must be violated
                      setCattleCropsAtMin(); //set the two crops at min
                      diff -= available;
                      double toIncrease = available;
                      increaseCrops(m_variableCrops2, toIncrease);
                      //throw an exception - restriction must be violated!
                     ofstream ofile("Restrictions.txt",ios::out);
                     ofile << m_almass_no << '\t' << "cattle restriction: broken after N 1" << endl;
                     ofile.close();
                  }
             }
 
         }//end of the second if(diff>0)
 
     }//end of the if(diff>0)?
 
 }//end of check CattleRotation

void OptimisingCattleFarm::checkCattleRotation_almass ( )

protected

Checks if the cattle restriction is fulfilled - in the ALMaSS crops mode.

Used in ALMaSS crop mode. Function checks if the restriction for cattle farms on attachment of spring barley, CloverGrassGrazed1 and CloverGrassGrazed2 is fulfilled. If not, it corrects these crops' areas.

Definition at line 6827 of file farm.cpp.

References OptimisingFarm::decreaseCrops(), OptimisingFarm::findCropByName_almass(), DataForOptimisation::Get_FUKey(), CropOptimised::m_areaPercent, OptimisingFarm::m_farmType, Farm::m_OurManager, CropOptimised::m_resp, OptimisingFarm::m_totalArea, OptimisingFarm::m_totalFUgrown, OptimisingFarm::m_totalFUt, CropOptimised::m_totalLoss, OptimisingFarm::m_variableCrops, OptimisingFarm::m_variableCrops2, FarmManager::pm_data, tov_CloverGrassGrazed1, tov_SpringBarley, and tov_Undefined.

                                                       {
     CropOptimised *sBarley = findCropByName_almass("SpringBarley"); //fodder
     CropOptimised *CGG1 = findCropByName_almass("CloverGrassGrazed1"); //fodder
     CropOptimised *CGG2 = findCropByName_almass("CloverGrassGrazed2"); //fodder
 
     double areaSBarley = sBarley->m_areaPercent;
     double areaCGG = 2*(CGG1->m_areaPercent); //cgg1 and 2 have equal areas - it waa checked  in Check_sg_and_cgg (called in check restrictions)
 
     double diff = areaCGG/2 - areaSBarley; //SpringBarley has to have an area at least as big as CGG1 = CGG2 = areaCGG/2.
 
     if(diff > 0){ //restriction is not fulfilled
 
         //need to make new variableCrops2 - without the grasses and sbarley!
         m_variableCrops2 = m_variableCrops; //initiate the new list and remove crops:
         for(int s=(int)m_variableCrops2.size()-1; s>=0; s--){
             if(m_variableCrops2[s].crop==sBarley || m_variableCrops2[s].crop==CGG1 || m_variableCrops2[s].crop==CGG2){
                 m_variableCrops2.erase(m_variableCrops2.begin() + s);
             }
         }
 
         double new_area_sbarley = areaSBarley;
         double new_area_cgg = areaCGG;
 
         double available=0; //all area except for fixed crops and min. areas of variable crops
         for(int i=0; i<(int)m_variableCrops.size(); i++){  //can't use m_grownVariableCrops - it doesn't include fodder crops!
             double areaVariableCrop = m_variableCrops[i].crop->m_areaPercent - m_variableCrops[i].crop->m_rotationMin;
             available += areaVariableCrop;
         }
 
         if(areaCGG/2 *3 <= available){ //then Sbarley can get as much as each CGG1; cgg area doesn't change
             new_area_sbarley = areaCGG/2;
             double area_to_decrease = new_area_sbarley - areaSBarley; // must be > 0 if this code is executed
             decreaseCrops(m_variableCrops2, area_to_decrease);
         }
         else{ //need to also cut grass, not just increase sbarley
             new_area_cgg = available/3 * 2; // = new area for sbarley = cgg1 = cgg2 (these 3 crops take all available area)
             new_area_sbarley = available/3;
             double current_sbarley_and_grasses = areaSBarley + areaCGG; // so other crops area (variable area) = 100 - current_sbarley_and_grasses
             double other_crops_area = available - current_sbarley_and_grasses;
             if(current_sbarley_and_grasses < available){ //there are other crops - and we're now substituting them with sbarley
                 decreaseCrops(m_variableCrops2, other_crops_area);
             }
             //else - just these 3 crops - do nothing - grass is already cut :), sbarley area is increased
         }
 
         //correct fodder....
         double resp = sBarley->m_resp;
         double loss = sBarley->m_totalLoss;
         int index = tov_Undefined*m_farmType + tov_SpringBarley;
         double FUKey = m_OurManager->pm_data->Get_FUKey(index);
         double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
         double changeFU = (new_area_sbarley - areaSBarley) * m_totalArea/100 * FUha; //positive
         m_totalFUt -= changeFU;
         m_totalFUgrown += changeFU;
 
         resp = CGG1->m_resp;
         loss = CGG1->m_totalLoss;
         index = tov_Undefined*m_farmType + tov_CloverGrassGrazed1;
         FUKey = m_OurManager->pm_data->Get_FUKey(index);
         FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
         changeFU = (areaCGG - new_area_cgg) * m_totalArea/100 * FUha; //positive
         m_totalFUt += changeFU;
         m_totalFUgrown -= changeFU;
 
         //and change the areas
         CGG1->m_areaPercent = new_area_cgg/2; //areaCGG is a summary area for both CGG
         CGG2->m_areaPercent = new_area_cgg/2;
         sBarley->m_areaPercent = new_area_sbarley;
 
     }
 
 }//end of check CattleRotation for almass crops

void OptimisingCattleFarm::checkRestrictions ( )

protectedvirtual

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

Includes additionally the function dealing with the cattle rotation restricton.

Reimplemented from OptimisingFarm.

Definition at line 5965 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, OptimisingFarm::checkRestrictions(), and CfgBool::value().

                                             {
     AnimalFarm::checkRestrictions();
 
     //3rd restriction: cattle crops
     if(cfg_OptimiseBedriftsmodelCrops.value()){
         checkCattleRotation();
     }
     else{
         checkCattleRotation_almass();
     }
 
 }

void OptimisingCattleFarm::preventCashCrops ( )

protectedvirtual

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

Prevents cattle farms on sandy soils with area < 15 ha from growing cash crops. For cattle farms on sandy soils larger than 15 ha and with the worse soil subtype - it prevents cash crops in 90% of cases. Farms above 15 ha with a good soil subtype are allowed to grow cash crops. Additionally, the function prevents cattle farms with area < 30 ha from growing maize silage.

Reimplemented from OptimisingFarm.

Definition at line 5227 of file farm.cpp.

References OptimisingFarm::findCropByName_almass(), CropOptimised::m_rotationMax, OptimisingFarm::m_soilSubType, OptimisingFarm::m_soilType, OptimisingFarm::m_totalArea_original, and tos_Sand.

                                            {
 
     CropOptimised *ms = findCropByName_almass ("MaizeSilage");
     if(m_totalArea_original < 30){ //cattle farms with area < 30 ha do not have maize silage!
         ms->m_rotationMax = 0;
     }
 
     CropOptimised *wwheat = findCropByName_almass ("WinterWheat");
     CropOptimised *wrye = findCropByName_almass ("WinterRye");
     CropOptimised *srape = findCropByName_almass ("SpringRape");
     CropOptimised *wrape = findCropByName_almass ("WinterRape");
     CropOptimised *fpeas = findCropByName_almass ("FieldPeas");
     CropOptimised *potatoes = findCropByName_almass ("Potatoes");
     CropOptimised *potind = findCropByName_almass ("PotatoesIndustry");
     CropOptimised *seedg1 = findCropByName_almass ("SeedGrass1");
     CropOptimised *seedg2 = findCropByName_almass ("SeedGrass2");
 
     if(m_soilType==tos_Sand && m_totalArea_original < 15){
 
         wwheat->m_rotationMax = 0;
         wrye->m_rotationMax = 0;
         srape->m_rotationMax = 0;
         wrape->m_rotationMax = 0;
         fpeas->m_rotationMax = 0;
         potatoes->m_rotationMax = 0;
         potind->m_rotationMax = 0;
         seedg1->m_rotationMax = 0;
         seedg2->m_rotationMax = 0;
 
         cash_crops_allowed=false;
     }
     else if(m_soilType==tos_Sand && m_totalArea_original >= 15 && m_soilSubType == 0){ //v. small prob. of having cash crops
 
             //see: http://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution
             std::random_device rd;
             std::mt19937 gen(rd());
             distribution_type2 dis(0, 1);
             double random_no = dis(gen);
 
             if(random_no > 0.1){ //so in 90% of cases
                 wwheat->m_rotationMax = 0;
                 wrye->m_rotationMax = 0;
                 srape->m_rotationMax = 0;
                 wrape->m_rotationMax = 0;
                 fpeas->m_rotationMax = 0;
                 potatoes->m_rotationMax = 0;
                 potind->m_rotationMax = 0;
                 seedg1->m_rotationMax = 0;
                 seedg2->m_rotationMax = 0;
 
                 cash_crops_allowed=false;
             }
     }
     //else nothing - allow cash crops
 
 }

void OptimisingCattleFarm::setCattleCropsAtMin ( )

protected

Decreases area of cattle crops to their min. required area.

In Bedriftsmodel crop mode, it decreases area of the two cattle crops (Grass Seed, Clover Grass) to their minimum required area (RotationMin).

Definition at line 6550 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, DataForOptimisation::Get_fodder(), DataForOptimisation::Get_FUKey(), OptimisingFarm::m_farmType, Farm::m_OurManager, OptimisingFarm::m_totalArea, OptimisingFarm::m_totalFUgrown, OptimisingFarm::m_totalFUt, FarmManager::pm_data, toc_Foobar, tov_Undefined, and CfgBool::value().

                                               {
     for(int i=0; i<(int)m_cattleCrops.size(); i++){ //just go through all 2 of them:)
         double area = m_cattleCrops[i].crop->m_areaPercent;
         double areaBefore = area;
         double rotationMin = m_cattleCrops[i].crop->m_rotationMin;
         area = rotationMin; //set all at min 
         m_cattleCrops[i].crop->m_areaPercent = area;
 
         if(areaBefore > area){
             int index = (cfg_OptimiseBedriftsmodelCrops.value())? toc_Foobar*m_farmType + m_cattleCrops[i].crop->m_cropType : tov_Undefined*m_farmType + m_cattleCrops[i].crop->m_cropType_almass;
             bool fodder = m_OurManager->pm_data->Get_fodder(index);
             if(fodder){
                 double resp = m_cattleCrops[i].crop->m_resp;
                 double loss = m_cattleCrops[i].crop->m_totalLoss;
                 double FUKey = m_OurManager->pm_data->Get_FUKey(index);
                 double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
                 double changeFU = (areaBefore - area) * m_totalArea/100 * FUha; //positive number
                 m_totalFUt += changeFU; //so you buy more
                 m_totalFUgrown -= changeFU; //and grow less:)
             }
         }
     }
 }

Member Data Documentation

vector<CropSort> OptimisingCattleFarm::m_cattleCrops

protected

Vector of crops used in checkCattleRotation.

Definition at line 2308 of file farm.h.

vector<CropSort> OptimisingCattleFarm::m_cattleCrops_almass

protected

Vector of crops used in checkCattleRotation_almass.

Definition at line 2314 of file farm.h.

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

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

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation