Subclass of the OptimisingFarm. Either plant or other farm. More...

#include <farm.h>

Inheritance diagram for NonAnimalFarm:

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

virtual	~NonAnimalFarm ()

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	findFodderDemand ()
	Determines farm's total demand for fodder (m_totalFUdemand). 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...

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

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

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

Additional Inherited Members
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 OptimisingFarm. Either plant or other farm.

Definition at line 2332 of file farm.h.

Constructor & Destructor Documentation

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

Definition at line 4799 of file farm.cpp.

                                                                    : OptimisingFarm(a_myfarmmanager, a_No){
     ;
 }

virtual NonAnimalFarm::~NonAnimalFarm ( )

inlinevirtual

Definition at line 2335 of file farm.h.

2335 {};

Member Function Documentation

void NonAnimalFarm::checkWinterCrops ( )

protectedvirtual

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

Function checking if the restriction on maximum winter crops area is fulfilled. If not, it corrects winter crops areas (starting with the one with the lowest GM) and assigns the area above the limit for winter crops to the most profitable variable crop(s) that haven't reached the maximimum area after the OptimisingFarm::determineAreas function was called. None of the winter crops is fixed.

Reimplemented from OptimisingFarm.

Definition at line 6359 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, OptimisingFarm::decreaseCrops(), OptimisingFarm::findCropByName(), OptimisingFarm::findCropByName_almass(), DataForOptimisation::Get_winterMax(), OptimisingFarm::increaseCrops(), OptimisingFarm::m_almass_no, CropOptimised::m_areaPercent, OptimisingFarm::m_farmType, Farm::m_OurManager, OptimisingFarm::m_variableCrops, OptimisingFarm::m_variableCrops2, OptimisingFarm::m_winterCrops, FarmManager::pm_data, OptimisingFarm::sortCrops(), and CfgBool::value().

Referenced by OptimisingFarm::checkRestrictions().

                                     {
 
     CropOptimised *wBarley;
     CropOptimised *wWheat;
     CropOptimised *wRye;
     CropOptimised *wRape;
     CropOptimised *wCerealSil = NULL; // Prevents warning
 
     if(cfg_OptimiseBedriftsmodelCrops.value()){
         wBarley = findCropByName("WBarley");
         wWheat = findCropByName("WWheat");
         wRye = findCropByName("WRye");
         wRape = findCropByName("WRape"); //should not be decreased - might cause violation of winterRotation restriction
         wCerealSil = findCropByName("WCerealSil");
     }
     else{
         wBarley = findCropByName_almass("WinterBarley");
         wWheat = findCropByName_almass("WinterWheat");
         wRye = findCropByName_almass("WinterRye");
         wRape = findCropByName_almass("WinterRape"); //should not be decreased - might cause violation of winterRotation restriction
     }
 
 
     double areaWBarley = wBarley->m_areaPercent;
     double areaWWheat = wWheat->m_areaPercent;
     double areaWRye = wRye->m_areaPercent;
     double areaWRape = wRape->m_areaPercent;
     double areaWCerealSil = 0;
 
     if(cfg_OptimiseBedriftsmodelCrops.value()){
         areaWCerealSil = wCerealSil->m_areaPercent; //it is used here only if it was initilized - in the bedriftsmodel crop mode
     }
 
     double sum = areaWBarley + areaWWheat + areaWRye + areaWRape + areaWCerealSil;
 
     int winterMax = m_OurManager->pm_data->Get_winterMax(m_farmType);
     if(sum > winterMax){
 
         m_variableCrops2 = m_variableCrops; //initiate the new list and remove all winter crops:
 
         if(cfg_OptimiseBedriftsmodelCrops.value()){
             for(int s=(int)m_variableCrops2.size()-1; s>=0; s--){
                 if(m_variableCrops2[s].crop==wBarley || m_variableCrops2[s].crop==wWheat || m_variableCrops2[s].crop==wRye || m_variableCrops2[s].crop==wRape || m_variableCrops2[s].crop==wCerealSil){
                     m_variableCrops2.erase(m_variableCrops2.begin() + s);
                 }
             }
         }
         else{
             for(int s=(int)m_variableCrops2.size()-1; s>=0; s--){
                 if(m_variableCrops2[s].crop==wBarley || m_variableCrops2[s].crop==wWheat || m_variableCrops2[s].crop==wRye || m_variableCrops2[s].crop==wRape){
                     m_variableCrops2.erase(m_variableCrops2.begin() + s);
                 }
             }
         }
 
         double diff = sum - winterMax;
         double diffBefore = diff;
 
         CropSort cs1 = {0., wBarley}; //an object with a key for sorting and a pointer to crop
         CropSort cs2 = {0., wWheat};
         CropSort cs3 = {0., wRye}; //CropSort cs4 = {0., wRape};
         m_winterCrops.clear();
         m_winterCrops.push_back(cs1);
         m_winterCrops.push_back(cs2);
         m_winterCrops.push_back(cs3);
 
         if(cfg_OptimiseBedriftsmodelCrops.value()){
             CropSort cs5 = {0., wCerealSil};
             m_winterCrops.push_back(cs5);
         }
 
         sortCrops(m_winterCrops, "GM");
 
         //decrease area of one or more winter crops by diff
         decreaseCrops(m_winterCrops, diff);
 
         if(diff > 0){ //loop in decreaseCrops was stopped by the other condition: impossible to cut more
             //violation of the restriction; do not exit, print warning
             ofstream ofile("Restrictions.txt",ios::app); 
             ofile << m_almass_no << '\t' << "winter crops restriction broken, non-animal farm. Diff is: " << diff << endl;
             ofile.close();
         }
 
         //assign area cut from winter crops to one or more variable crops (that haven't reached the max yet)
         double toIncrease = diffBefore - diff; 
         increaseCrops(m_variableCrops2, toIncrease);
 
     }//else nothing!:) it's ok
 
 }//end of checkWinterCrops

void NonAnimalFarm::checkWinterRotation1 ( )

protectedvirtual

Checks if the restriction on a winter rotation is fulfilled.

Function checks if the restriction on rotation: area(WWheat) - (area(WRape) + area(SRape) + area(FieldPeas) + area(Oats)) <=0, is fulfilled. If not, it corrects crops areas (excluding the fixed crop, FieldPeas).

Reimplemented from OptimisingFarm.

Definition at line 5992 of file farm.cpp.

References cfg_OptimiseBedriftsmodelCrops, OptimisingFarm::decreaseCrops(), OptimisingFarm::findCropByName(), OptimisingFarm::findCropByName_almass(), OptimisingFarm::increaseCrops(), OptimisingFarm::m_almass_no, CropOptimised::m_areaPercent, CropOptimised::m_GM, OptimisingFarm::m_rotationCrops, CropOptimised::m_rotationMin, OptimisingFarm::m_variableCrops, OptimisingFarm::m_variableCrops2, OptimisingFarm::sortCrops(), and CfgBool::value().

Referenced by OptimisingFarm::checkRestrictions().

                                         {
 
     CropOptimised *wWheat;
     CropOptimised *wRape;
     CropOptimised *sRape;
     CropOptimised *oats;
     CropOptimised *peas;
 
     if(cfg_OptimiseBedriftsmodelCrops.value()){
         wWheat = findCropByName("WWheat");
         wRape = findCropByName("WRape");
         sRape = findCropByName("SRape");
         oats = findCropByName("Oats");
         peas = findCropByName("Peas"); //fixed
     }
     else{
         wWheat = findCropByName_almass("WinterWheat");
         wRape = findCropByName_almass("WinterRape");
         sRape = findCropByName_almass("SpringRape");
         oats = findCropByName_almass("Oats");
         peas = findCropByName_almass("FieldPeas"); //fixed
     }
 
     double areaWWheat = wWheat->m_areaPercent;
     double areaWRape = wRape->m_areaPercent;
     double areaSRape = sRape->m_areaPercent;
     double areaOats = oats->m_areaPercent;
     double areaPeas = peas->m_areaPercent;
 
     double diff = areaWWheat - (areaWRape + areaSRape + areaOats + areaPeas); //difference;
     if (diff > 0){ //restriction is not fulfilled
         CropSort cs1 = {0., wRape}; //an object with a key for sorting and a pointer to crop
         CropSort cs2 = {0., sRape};
         CropSort cs3 = {0., oats};
         m_rotationCrops.clear();
         m_rotationCrops.push_back(cs1);
         m_rotationCrops.push_back(cs2);
         m_rotationCrops.push_back(cs3);
 
         sortCrops(m_rotationCrops, "GM"); //sorting the rotation crops wrt GM
 
         m_variableCrops2 = m_variableCrops; //initialize the new list and remove all 'winter rotation' crops:
         for(int s =(int)m_variableCrops2.size()-1; s>=0; s--){
             if(m_variableCrops2[s].crop==wWheat || m_variableCrops2[s].crop==wRape || m_variableCrops2[s].crop==sRape || m_variableCrops2[s].crop==oats){
                 m_variableCrops2.erase(m_variableCrops2.begin() + s);
             }
         }
 
         double GM_WWheat = wWheat->m_GM;
         double areaMin = wWheat->m_rotationMin;
 
         for(int i=0; i<(int)m_rotationCrops.size() && diff!=0; i++){
             double areaRC = m_rotationCrops[i].crop->m_areaPercent;
             double rotationMaxRC = m_rotationCrops[i].crop->m_rotationMax;
             if(areaRC < rotationMaxRC){
                 double GM_RC = m_rotationCrops[i].crop->m_GM;
                 bool stopInnerLoop = false;
 
                 for(int j=0; j<(int)m_variableCrops2.size() && stopInnerLoop==false; j++){
 
                     double GM_var = m_variableCrops2[j].crop->m_GM;
 
                     if(GM_RC + GM_WWheat < 2*GM_var){
                         //add the variable crop
                         double areaVC = m_variableCrops2[j].crop->m_areaPercent;
                         double rotationMaxVC = m_variableCrops2[j].crop->m_rotationMax;
                         if(areaWWheat - areaMin >= diff){
                             if(rotationMaxVC - areaVC >= diff){
                                 areaVC += diff;
                                 areaWWheat -= diff;
                                 diff = 0; //finito
                                 stopInnerLoop = true;
                             }
                             else{
                                 areaWWheat -= rotationMaxVC - areaVC;
                                 diff -= (rotationMaxVC - areaVC);
                                 areaVC = rotationMaxVC;
                             }
                         }
                         else{
                             if(rotationMaxVC - areaVC >= areaWWheat - areaMin){
                                 areaVC += areaWWheat - areaMin;
                                 diff -= (areaWWheat - areaMin);
                                 areaWWheat = areaMin; // now you can only add rot crops! so stop the inner loop
                                 stopInnerLoop = true;
                             }
                             else{
                                 areaWWheat -= rotationMaxVC - areaVC;
                                 diff -= (rotationMaxVC - areaVC);
                                 areaVC = rotationMaxVC;
                             }
                         }
                         m_variableCrops2[j].crop->m_areaPercent = areaVC;
                     }
 
                     else{
                             //add rotational crop
 
                             if(areaWWheat - areaMin >= diff/2){
                                 if(rotationMaxRC - areaRC >= diff/2){
                                     areaRC += diff/2;
                                     areaWWheat -= diff/2;
                                     diff = 0; //finito
                                     stopInnerLoop = true;
                                 }
                                 else{
                                     areaWWheat -= rotationMaxRC - areaRC;
                                     diff -= 2 * (rotationMaxRC - areaRC);
                                     areaRC = rotationMaxRC;
                                     stopInnerLoop = true; //take next rotation crop
                                 }
                             }
                             else{
                                 if(rotationMaxRC - areaRC >= areaWWheat - areaMin){
                                     areaRC += areaWWheat - areaMin;
                                     diff -= 2 * (areaWWheat - areaMin);
                                     areaWWheat = areaMin; //now you can only add rot crops!//so stop the inner loop:
                                     stopInnerLoop = true;
                                 }
                                 else{
                                     areaWWheat -= rotationMaxRC - areaRC;
                                     diff -= 2 * (rotationMaxRC - areaRC);
                                     areaRC = rotationMaxRC;
                                     stopInnerLoop = true; //take the next rotation crop
                                 }
                             }
                         }
                     }//inner for-loop
                 m_rotationCrops[i].crop->m_areaPercent = areaRC;
                 }//if rot crop<rotmax //else - take the next rot crop, i++
             }//outer for
 
         //now the diff can be positive in two cases:
 
         //1. wwheat area is at zero - need to increase rotation crops - if possible
         if(areaWWheat==areaMin && diff > 0){
             double diff1=diff;
             increaseCrops(m_rotationCrops, diff1);
             if(diff1==0) {decreaseCrops(m_variableCrops2, diff);} //do it only if we actually managed to add the diff (=diff1)
             //to the rotation crops,i.e. diff1=0; if it's >0, then we added smth, but not enough and restriction can't be fulfilled.Then:
             else{
                 double toCut = diff - diff1;
                 decreaseCrops(m_variableCrops2, toCut);
                 diff = diff1; //restriction will be broken by diff1
                 ofstream ofile("Restrictions.txt",ios::app); 
                 ofile << m_almass_no << '\t' << "winter rotation1 restriction broken, WWheat area at 0. Diff is: " << diff << endl;
                 ofile.close();
             }
         }
 
         //2. it was always more profitable to grow rotation crops, but they were not
         //enough (maybe at max from the beginning) - increase variable crops, cut wwheat
 
         if(diff > 0   &&   areaWWheat - areaMin >= diff){
             areaWWheat -= diff;
             increaseCrops(m_variableCrops2, diff);
         }
 
         wWheat->m_areaPercent = areaWWheat;
 
     }//if
 }//end of the function

void NonAnimalFarm::findFodderDemand ( )

protectedvirtual

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

For non-animal farms, the function assigns the value of the total fodder demand to the variable m_totalFUt (total fodder purchased) and it sets m_totalFUgrown (total fodder grown) to zero.

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

Reimplemented from OptimisingFarm.

Definition at line 5216 of file farm.cpp.

References OptimisingFarm::findFodderDemand(), OptimisingFarm::m_totalFUdemand, OptimisingFarm::m_totalFUgrown, and OptimisingFarm::m_totalFUt.

Referenced by OptimisingFarm::FarmLevelCalculation().

                                     {
 
     OptimisingFarm::findFodderDemand();
     m_totalFUt=m_totalFUdemand;
     m_totalFUdemand=0;
     m_totalFUgrown=0;
 }

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

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation