ALMaSS Rabbit ODdox  1.1
The rabbit model description following ODdox protocol
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
AnimalFarm Class Reference

Subclass of the OptimisingFarm. Either pig or cattle farm. More...

#include <farm.h>

Inheritance diagram for AnimalFarm:
OptimisingFarm Farm OptimisingCattleFarm OptimisingPigFarm

Public Member Functions

 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 StubblePlough (LE *a_field, double a_user, int a_days)
 Carry out a stubble ploughing event on a_field. This is similar to normal plough but shallow (normally 6-8cm, is special cases up to 12-15cm). Done as a part of after-harvest treatments (instead of stubble cultivation) More...
 
virtual bool StubbleCultivatorHeavy (LE *a_field, double a_user, int a_days)
 Carry out a stubble cultivation event on a_field. This is non-inversion type of cultivation which can be done instead of autumn plough (on a depth up to 40 cm even, if necessary) 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 PreseedingCultivator (LE *a_field, double a_user, int a_days)
 Carry out preseeding cultivation on a_field (tilling set including cultivator and string roller to compact soil) More...
 
virtual bool PreseedingCultivatorSow (LE *a_field, double a_user, int a_days)
 Carry out preseeding cultivation together with sow on a_field (tilling and sowing set including cultivator and string roller to compact soil) 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 SpringSowWithFerti (LE *a_field, double a_user, int a_days)
 Carry out a sowing event with start fertilizer 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 ProductApplication (LE *a_field, double a_user, int a_days, double a_applicationrate, PlantProtectionProducts a_ppp)
 Apply test pesticide to a_field. More...
 
virtual bool ProductApplication_DateLimited (LE *a_field, double, int, double a_applicationrate, PlantProtectionProducts a_ppp)
 Special pesticide trial functionality. 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 StriglingHill (LE *a_field, double a_user, int a_days)
 Carry out a mechanical weeding on a_field followed by hilling up (probably on potatoes) 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_AmmoniumSulphate (LE *a_field, double a_user, int a_days)
 Apply Ammonium 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 FP_RSM (LE *a_field, double a_user, int a_days)
 RSM (ammonium nitrate solution) applied on a_field owned by an arable farmer. More...
 
virtual bool FP_Calcium (LE *a_field, double a_user, int a_days)
 Calcium applied on a_field owned by an arable farmer. More...
 
virtual bool FA_NPKS (LE *a_field, double a_user, int a_days)
 Apply NPKS fertilizer, on a_field owned by a stock 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_ManganeseSulphate (LE *a_field, double a_user, int a_days)
 Apply manganese sulphate to a_field owned by an stock farmer. More...
 
virtual bool FA_AmmoniumSulphate (LE *a_field, double a_user, int a_days)
 Apply ammonium sulphate 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 FA_RSM (LE *a_field, double a_user, int a_days)
 RSM (ammonium nitrate solution) applied on a_field owned by a stock farmer. More...
 
virtual bool FA_Calcium (LE *a_field, double a_user, int a_days)
 Calcium applied on a_field owned by a stock farmer. More...
 
virtual bool Biocide (LE *a_field, double a_user, int a_days)
 Biocide applied on a_field. More...
 
virtual bool BedForming (LE *a_field, double a_user, int a_days)
 Do bed forming up on a_field, probably of carrots. More...
 
virtual bool ShallowHarrow (LE *a_field, double a_user, int a_days)
 Carry out a shallow harrow event on a_field, e.g., after grass cutting event. More...
 
virtual bool HeavyCultivatorAggregate (LE *a_field, double a_user, int a_days)
 Carry out a heavy cultivation event on a_field. This is non-inversion type of cultivation which can be done after fertilizers application on spring for a spring crop. More...
 
virtual bool FlowerCutting (LE *a_field, double a_user, int a_days)
 Flower cutting applied on a_field. More...
 
virtual bool BulbHarvest (LE *a_field, double a_user, int a_days)
 Carry out a bulb harvest on a_field. More...
 
virtual bool StrawCovering (LE *a_field, double a_user, int a_days)
 Straw covering applied on a_field. More...
 
virtual bool StrawRemoval (LE *a_field, double a_user, int a_days)
 Straw covering applied on a_field. More...
 
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 (double a_probability)
 Return chance out of 0 to 100. More...
 
bool DoIt_prob (double a_probability)
 Return chance out of 0 to 1. 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)
 
void RemoveHunter (Hunter *a_hunter)
 

Protected Member Functions

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

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
 
NorwegianPotatoes * m_norwegianpotatoes
 
NorwegianOats * m_norwegianoats
 
NorwegianSpringBarley * m_norwegianspringbarley
 
PLWinterWheat * m_plwinterwheat
 
PLWinterRape * m_plwinterrape
 
PLWinterBarley * m_plwinterbarley
 
PLWinterTriticale * m_plwintertriticale
 
PLWinterRye * m_plwinterrye
 
PLSpringWheat * m_plspringwheat
 
PLSpringBarley * m_plspringbarley
 
PLMaize * m_plmaize
 
PLMaizeSilage * m_plmaizesilage
 
PLPotatoes * m_plpotatoes
 
PLBeet * m_plbeet
 
PLFodderLucerne1 * m_plfodderlucerne1
 
PLFodderLucerne2 * m_plfodderlucerne2
 
PLCarrots * m_plcarrots
 
PLSpringBarleySpr * m_plspringbarleyspr
 
PLWinterWheatLate * m_plwinterwheatlate
 
PLBeetSpr * m_plbeetspr
 
PLBeans * m_plbeans
 
NLBeet * m_nlbeet
 
NLCarrots * m_nlcarrots
 
NLMaize * m_nlmaize
 
NLPotatoes * m_nlpotatoes
 
NLSpringBarley * m_nlspringbarley
 
NLWinterWheat * m_nlwinterwheat
 
NLCabbage * m_nlcabbage
 
NLTulips * m_nltulips
 
NLGrassGrazed1 * m_nlgrassgrazed1
 
NLGrassGrazed1Spring * m_nlgrassgrazed1spring
 
NLGrassGrazed2 * m_nlgrassgrazed2
 
NLGrassGrazedLast * m_nlgrassgrazedlast
 
NLPermanentGrassGrazed * m_nlpermanentgrassgrazed
 
NLBeetSpring * m_nlbeetspring
 
NLCarrotsSpring * m_nlcarrotsspring
 
NLMaizeSpring * m_nlmaizespring
 
NLPotatoesSpring * m_nlpotatoesspring
 
NLSpringBarleySpring * m_nlspringbarleyspring
 
NLCabbageSpring * m_nlcabbagespring
 
NLCatchPeaCrop * m_nlcatchpeacrop
 
DummyCropPestTesting * m_dummycroppesttesting
 

Detailed Description

Subclass of the OptimisingFarm. Either pig or cattle farm.

Definition at line 2375 of file farm.h.

Constructor & Destructor Documentation

◆ AnimalFarm()

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

Definition at line 5270 of file farm.cpp.

5270  : OptimisingFarm(a_fred, a_No)
5271 {
5272  m_fakeCrop = new CropOptimised(); //("FakeCrop", 0)
5273  cash_crops_allowed = true;
5274 }

References cash_crops_allowed, and m_fakeCrop.

◆ ~AnimalFarm()

virtual AnimalFarm::~AnimalFarm ( )
inlinevirtual

Definition at line 2378 of file farm.h.

2378 {};

Member Function Documentation

◆ checkWinterCrops()

void AnimalFarm::checkWinterCrops ( )
protectedvirtual

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

Function for animal farms checking if restriction on maximum winter crops area is fulfilled. Works in the same way as the NonAnimalFarm version, but additionally accounts for fodder changes. In Bedriftsmodel crop mode, both for cattle and pig farms two of the winter crops, WBarley and WCerealSil, are fodder crops. In the ALMaSS crop mode, WCerealSil does not exist (is aggregated to another crop) and is thus excluded from the restriction's condition.

Reimplemented from OptimisingFarm.

Definition at line 6932 of file farm.cpp.

6932  {
6933 
6939  CropOptimised *wBarley;
6940  CropOptimised *wWheat;
6941  CropOptimised *wRye;
6942  CropOptimised *wRape;
6943  CropOptimised *wCerealSil = NULL; // To prevent the annoying warning
6944 
6945  if(cfg_OptimiseBedriftsmodelCrops.value()){
6946  wBarley = findCropByName("WBarley");
6947  wWheat = findCropByName("WWheat");
6948  wRye = findCropByName("WRye");
6949  wRape = findCropByName("WRape"); //should not be decreased - might cause violation of winterRotation restriction
6950  wCerealSil = findCropByName("WCerealSil");
6951  }
6952  else{
6953  wBarley = findCropByName_almass("WinterBarley");
6954  wWheat = findCropByName_almass("WinterWheat");
6955  wRye = findCropByName_almass("WinterRye");
6956  wRape = findCropByName_almass("WinterRape"); //should not be decreased - might cause violation of winterRotation restriction
6957  }
6958 
6959  double areaWBarley = wBarley->m_areaPercent;
6960  double areaWWheat = wWheat->m_areaPercent;
6961  double areaWRye = wRye->m_areaPercent;
6962  double areaWRape = wRape->m_areaPercent;
6963  double areaWCerealSil = 0;
6964 
6965  if(cfg_OptimiseBedriftsmodelCrops.value()){
6966  areaWCerealSil = wCerealSil->m_areaPercent;
6967  }
6968 
6969  double sum = areaWBarley + areaWWheat + areaWRye + areaWRape + areaWCerealSil;
6970 
6971  int winterMax = m_OurManager->pm_data->Get_winterMax(m_farmType);
6972  if(sum > winterMax){
6973  double diff = sum - winterMax;
6974  double diffBefore = diff;
6975 
6976  m_variableCrops2 = m_variableCrops; //initiate the new list and remove all winter crops:
6977  if(cfg_OptimiseBedriftsmodelCrops.value()){
6978  for(int s=(int)m_variableCrops2.size()-1; s>=0; s--){
6979  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){
6980  m_variableCrops2.erase(m_variableCrops2.begin() + s);
6981  }
6982  }
6983  }
6984  else{
6985  for(int s=(int)m_variableCrops2.size()-1; s>=0; s--){
6986  if(m_variableCrops2[s].crop==wBarley || m_variableCrops2[s].crop==wWheat || m_variableCrops2[s].crop==wRye || m_variableCrops2[s].crop==wRape){
6987  m_variableCrops2.erase(m_variableCrops2.begin() + s);
6988  }
6989  }
6990  }
6991 
6992  //assign keys for sorting - for fodder crops these will be Savings!
6993  CropSort cs1 = {0., wBarley}; //an object with a key for sorting and a pointer to crop
6994  CropSort cs2 = {0., wWheat};
6995  CropSort cs3 = {0., wRye};//CropSort cs4 = {wRape->pullVariable<double>("GM"), wRape};
6996 
6997  m_winterCrops.clear();
6998  m_winterCrops.push_back(cs1);
6999  m_winterCrops.push_back(cs2);
7000  m_winterCrops.push_back(cs3);
7001 
7002  if(cfg_OptimiseBedriftsmodelCrops.value()){
7003  CropSort cs5 = {0., wCerealSil};
7004  m_winterCrops.push_back(cs5);
7005  }
7006 
7007  sortCrops(m_winterCrops, "GM_Savings");
7008 
7009  //decrease area of one or more winter crops by diff
7010  decreaseCrops(m_winterCrops, diff);
7011 
7012  if(diff>0){ //loop stopped by the other condition: impossible to cut more
7013  //violation of the restriction; do not exit, just print a warning
7014  ofstream ofile("Restrictions.txt",ios::app);
7015  ofile << m_almass_no << '\t' << "winter crops restriction broken, Animal farm. Diff is: " << diff << endl;
7016  ofile.close();
7017  }
7018 
7019  //assign the area cut from winter crops to one or more variable crops (that haven't reached the max yet)
7020  double toIncrease = diffBefore - diff;
7021  increaseCrops(m_variableCrops2, toIncrease);
7022 
7023  }//else nothing!:) it's ok
7024 
7025 }//end of checkWinterCropsAnimal

References cfg_OptimiseBedriftsmodelCrops, decreaseCrops(), OptimisingFarm::findCropByName(), OptimisingFarm::findCropByName_almass(), DataForOptimisation::Get_winterMax(), 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().

◆ checkWinterRotation1()

void AnimalFarm::checkWinterRotation1 ( )
protectedvirtual

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

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). In case area of a fodder crop is changed, the value of OptimisingFarm::m_totalFUt is updated.

Reimplemented from OptimisingFarm.

Definition at line 6636 of file farm.cpp.

6636  {
6637 
6642  CropOptimised *wWheat;
6643  CropOptimised *wRape;
6644  CropOptimised *sRape;
6645  CropOptimised *oats;
6646  CropOptimised *peas;
6647 
6648  if(cfg_OptimiseBedriftsmodelCrops.value()){
6649  wWheat = findCropByName("WWheat");
6650  wRape = findCropByName("WRape");
6651  sRape = findCropByName("SRape");
6652  oats = findCropByName("Oats");//fodder
6653  peas = findCropByName("Peas"); //fixed
6654  }
6655  else{
6656  wWheat = findCropByName_almass("WinterWheat");
6657  wRape = findCropByName_almass("WinterRape");
6658  sRape = findCropByName_almass("SpringRape");
6659  oats = findCropByName_almass("Oats");//fodder
6660  peas = findCropByName_almass("FieldPeas"); //fixed
6661  }
6662 
6663  double areaWWheat = wWheat->m_areaPercent;
6664  double areaWRape = wRape->m_areaPercent;
6665  double areaSRape = sRape->m_areaPercent;
6666  double areaOats = oats->m_areaPercent;
6667  double areaPeas = peas->m_areaPercent;
6668 
6669  double diff = areaWWheat - (areaWRape + areaSRape + areaOats + areaPeas); //difference;
6670  if (diff > 0){ //restriction is not fulfilled
6671  CropSort cs1 = {0., wRape}; //an object with a key for sorting and a pointer to crop
6672  CropSort cs2 = {0., sRape};
6673  CropSort cs3 = {0., oats};
6674  m_rotationCrops.clear();
6675  m_rotationCrops.push_back(cs1);
6676  m_rotationCrops.push_back(cs2);
6677  m_rotationCrops.push_back(cs3);
6678 
6679  sortCrops(m_rotationCrops, "GM_Savings"); //sorting the rotation crops wrt GM
6680 
6681 
6682  m_variableCrops2 = m_variableCrops; //initiate the new list and remove all 'winter rotation' crops:
6683  for(int s=(int)m_variableCrops2.size()-1; s>=0; s--){
6684  if(m_variableCrops2[s].crop==wWheat || m_variableCrops2[s].crop==wRape || m_variableCrops2[s].crop==sRape || m_variableCrops2[s].crop==oats){
6685  m_variableCrops2.erase(m_variableCrops2.begin() + s);
6686  }
6687  }
6688 
6689  double GM_WWheat = wWheat->m_GM;
6690  double areaMin = wWheat->m_rotationMin;
6691 
6692  for(int i=0; i<(int)m_rotationCrops.size() && diff!=0; i++){
6693  double areaRC = m_rotationCrops[i].crop->m_areaPercent;
6694  double rotationMaxRC = m_rotationCrops[i].crop->m_rotationMax;
6695  double areaBeforeRC = areaRC;
6696  if(areaRC < rotationMaxRC){
6697  double GM_RC = m_rotationCrops[i].crop->m_GM_Savings;
6698  bool stopInnerLoop = false;
6699 
6700  for(int j=0; j<(int)m_variableCrops2.size() && stopInnerLoop==false; j++){
6701 
6702  double GM_var = m_variableCrops2[j].crop->m_GM_Savings;
6703 
6704  if(GM_RC + GM_WWheat < 2 * GM_var){
6705  //add variable
6706  double areaVC = m_variableCrops2[j].crop->m_areaPercent;
6707  double rotationMaxVC = m_variableCrops2[j].crop->m_rotationMax;
6708  double areaBefore = areaVC;
6709  if(areaWWheat - areaMin >= diff){
6710  if(rotationMaxVC - areaVC >= diff){
6711  areaVC += diff;
6712  areaWWheat -= diff;
6713  diff = 0; //finished
6714  stopInnerLoop = true;
6715  }
6716  else{
6717  areaWWheat -= rotationMaxVC - areaVC;
6718  diff -= (rotationMaxVC - areaVC);
6719  areaVC = rotationMaxVC;
6720  }
6721  }
6722  else{
6723  if(rotationMaxVC - areaVC >= areaWWheat - areaMin){
6724  areaVC += (areaWWheat - areaMin);
6725  diff -= (areaWWheat - areaMin);
6726  areaWWheat = areaMin; //now you can only add rot crops! so stop the inner loop
6727  stopInnerLoop=true;
6728  }
6729  else{
6730  areaWWheat -= rotationMaxVC - areaVC;
6731  diff -= (rotationMaxVC - areaVC);
6732  areaVC = rotationMaxVC;
6733  }
6734  }
6735  m_variableCrops2[j].crop->m_areaPercent = areaVC;
6736  //this just in an animal version, add if - checking if area has changed
6737  if(areaVC > areaBefore){
6738  int index = (cfg_OptimiseBedriftsmodelCrops.value())? toc_Foobar*m_farmType + m_variableCrops2[j].crop->m_cropType : tov_Undefined*m_farmType + m_variableCrops2[j].crop->m_cropType_almass;
6739  bool fodder = m_OurManager->pm_data->Get_fodder(index);
6740  if(fodder){ //this is a fodder crop - so you need to buy less fodder - totalFUt
6741  double resp = m_variableCrops2[j].crop->m_resp;
6742  double loss = m_variableCrops2[j].crop->m_totalLoss;
6743  double FUKey = m_OurManager->pm_data->Get_FUKey(index);
6744  double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
6745  double changeFU = (areaVC - areaBefore) * m_totalArea/100 * FUha; //positive
6746  m_totalFUt -= changeFU;
6747  m_totalFUgrown+=changeFU;
6748  }
6749  }
6750  }
6751  else{
6752  //add rotational
6753 
6754  if(areaWWheat - areaMin >= diff/2){
6755  if(rotationMaxRC - areaRC >= diff/2){
6756  areaRC += diff/2;
6757  areaWWheat -= diff/2;
6758  diff = 0; //finito
6759  stopInnerLoop = true;
6760  }
6761  else{
6762  areaWWheat -= rotationMaxRC - areaRC;
6763  diff -= 2 * (rotationMaxRC - areaRC);
6764  areaRC = rotationMaxRC;
6765  stopInnerLoop = true; //take next rotation crop
6766  }
6767  }
6768  else{
6769  if(rotationMaxRC - areaRC >= areaWWheat - areaMin){
6770  areaRC += areaWWheat - areaMin;
6771  diff -= 2 * (areaWWheat - areaMin);
6772  areaWWheat = areaMin; //now you can only add rot crops! so stop the inner loop:
6773  stopInnerLoop = true;
6774  }
6775  else{
6776  areaWWheat -= rotationMaxRC - areaRC;
6777  diff -= 2 * (rotationMaxRC - areaRC);
6778  areaRC = rotationMaxRC;
6779  stopInnerLoop = true; //take the next rotation crop
6780  }
6781  }
6782  }
6783  }//inner for-loop
6784 
6785  m_rotationCrops[i].crop->m_areaPercent = areaRC;
6786  //this just in an animal version, add if - checking if area has changed
6787  if(areaRC>areaBeforeRC){
6788  int index = (cfg_OptimiseBedriftsmodelCrops.value())? toc_Foobar*m_farmType + m_rotationCrops[i].crop->m_cropType : tov_Undefined*m_farmType + m_rotationCrops[i].crop->m_cropType_almass;
6789  bool fodder = m_OurManager->pm_data->Get_fodder(index);
6790  if(fodder){ //this is a fodder crop - so you need to buy less fodder - totalFUt
6791  double resp = m_rotationCrops[i].crop->m_resp;
6792  double loss = m_rotationCrops[i].crop->m_totalLoss;
6793  double FUKey = m_OurManager->pm_data->Get_FUKey(index);
6794  double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
6795  double changeFU = (areaRC - areaBeforeRC) * m_totalArea/100 * FUha; //positive
6796  m_totalFUt -= changeFU;
6797  m_totalFUgrown += changeFU;
6798  }
6799  }
6800  }//if rot crop<rotmax//else - take the next rot crop, i++
6801  }//outer for
6802 
6803  //now the diff can be positive in two cases:
6804 
6805  //1. wwheat area is at zero - need to increase rotation crops - if possible
6806  if(areaWWheat==areaMin && diff>0){
6807  double diff1 = diff;
6808  increaseCrops(m_rotationCrops, diff1);
6809  if(diff1==0) {decreaseCrops(m_variableCrops2, diff);} //do it only if we actually
6810  //managed to diff (=diff1) to the rotation crops,so diff1=0; if it's (0, diff)-then
6811  //we added smth, but not enough and restriction can't be fulfilled...- then...
6812  else{
6813  double toCut = diff-diff1;
6814  decreaseCrops(m_variableCrops2, toCut);
6815  diff = diff1; //restriction will be broken by diff1
6816  ofstream ofile("Restrictions.txt",ios::app);
6817  ofile << m_almass_no << '\t' << "winter rotation1 restriction broken. Animal farm. WWheat area at 0. Diff is: " << diff << endl;
6818  ofile.close();
6819  }
6820  }
6821 
6822  //2. it was always more profitable to grow rotation crops, but they were not
6823  //enough (maybe at max from the beginning) - increase variable crops, cut wwheat
6824 
6825  if(diff>0 && areaWWheat-areaMin >= diff){
6826  areaWWheat -= diff;
6827  increaseCrops(m_variableCrops2, diff);
6828  }
6829 
6830  wWheat->m_areaPercent = areaWWheat;
6831 
6832  }//if
6833 
6834 }//end of the function

References cfg_OptimiseBedriftsmodelCrops, decreaseCrops(), OptimisingFarm::findCropByName(), OptimisingFarm::findCropByName_almass(), DataForOptimisation::Get_fodder(), DataForOptimisation::Get_FUKey(), increaseCrops(), OptimisingFarm::m_almass_no, CropOptimised::m_areaPercent, OptimisingFarm::m_farmType, CropOptimised::m_GM, Farm::m_OurManager, OptimisingFarm::m_rotationCrops, CropOptimised::m_rotationMin, OptimisingFarm::m_totalArea, OptimisingFarm::m_totalFUgrown, OptimisingFarm::m_totalFUt, OptimisingFarm::m_variableCrops, OptimisingFarm::m_variableCrops2, FarmManager::pm_data, OptimisingFarm::sortCrops(), toc_Foobar, tov_Undefined, and CfgBool::value().

◆ correctFodderDemand()

void AnimalFarm::correctFodderDemand ( int  a_foobar)
protected

Determines how much fodder is produced from fixed crops and min. areas of variable crops.

Function determining how much fodder is produced from fixed crops and minimial areas of variable crops. Updates the variable holding the value of the total fodder demand for a farm, m_totalFUdemand. Updates a variable holding the value of the fodder that has to be obtained from own production.

Definition at line 7488 of file farm.cpp.

7488  {
7493  m_totalFUgrown=0; //initialize
7494 
7495  double min_fodder = (m_farmType == toof_Pig) ? cfg_Min_fodder_prod_pig.value() : cfg_Min_fodder_prod_cattle.value(); //there are only two types of animal farms
7496  m_totalFodderToProduce = (min_fodder/100)*m_totalFUdemand; //[FU]
7497 
7498  double fodderFromFixed=0;
7499  for (int i=0; i<(int)m_fixedCrops.size(); i++){
7500  double area_percent = m_fixedCrops[i]->m_areaPercent;
7501  if(area_percent!=0){
7502  double area = area_percent/100* m_totalArea;
7503  double resp = m_fixedCrops[i]->m_resp;
7504  double loss = m_fixedCrops[i]->m_totalLoss;
7505 
7506  int index = (cfg_OptimiseBedriftsmodelCrops.value())? a_foobar*m_farmType + m_fixedCrops[i]->m_cropType : a_foobar*m_farmType + m_fixedCrops[i]->m_cropType_almass;
7507  double FUKey = m_OurManager->pm_data->Get_FUKey(index);//if it is not a fodder crop, key=0
7508  double FU = area*resp*(1-loss/100)*FUKey; //[ha * hkg/ha * FU/hkg = FU]
7509  fodderFromFixed += FU;//0 will be added in case of non-fodder crops
7510  m_totalFUgrown += FU;
7511  }
7512  }
7513  double fodderFromMinAreas=0;
7514  for (int i=0; i<(int)m_variableCrops.size(); i++){
7515  double areaMinPercent = m_variableCrops[i].crop->m_rotationMin;
7516  if(areaMinPercent!=0){ //150713
7517  double area = areaMinPercent/100*m_totalArea; //min area in ha
7518  double resp = m_variableCrops[i].crop->m_resp;
7519  double loss = m_variableCrops[i].crop->m_totalLoss;
7520 
7521  int index = (cfg_OptimiseBedriftsmodelCrops.value())? a_foobar*m_farmType + m_variableCrops[i].crop->m_cropType : a_foobar*m_farmType + m_variableCrops[i].crop->m_cropType_almass;
7522  double FUKey = m_OurManager->pm_data->Get_FUKey(index);//if it is not a fodder crop, key=0
7523  double FU = area*resp*(1-loss/100)*FUKey; //[ha * hkg/ha * FU/hkg = FU]
7524  fodderFromMinAreas += FU;
7525  m_totalFUgrown += FU;
7526  }
7527  }
7528  //this much fodder HAS to be obtained from self-production IF the requirment
7529  //on min fodder production holds; might be negative!
7530 
7531  m_fodderToProduce = m_totalFodderToProduce - (fodderFromFixed + fodderFromMinAreas);
7532  m_fodderToProduceBefore = m_fodderToProduce;
7533 
7534  //decrease the fodder demand by the amount obtained from growing fixed crops and from
7535  //min areas of variable crops; could be also negative now;
7536  m_totalFUdemand -= (fodderFromFixed + fodderFromMinAreas);
7537 
7538 }

References cfg_Min_fodder_prod_cattle, cfg_Min_fodder_prod_pig, cfg_OptimiseBedriftsmodelCrops, DataForOptimisation::Get_FUKey(), OptimisingFarm::m_farmType, OptimisingFarm::m_fixedCrops, m_fodderToProduce, m_fodderToProduceBefore, Farm::m_OurManager, OptimisingFarm::m_totalArea, m_totalFodderToProduce, OptimisingFarm::m_totalFUdemand, OptimisingFarm::m_totalFUgrown, OptimisingFarm::m_variableCrops, FarmManager::pm_data, toof_Pig, CfgFloat::value(), and CfgBool::value().

Referenced by determineAreas().

◆ createCropsLists()

void AnimalFarm::createCropsLists ( int  a_foobar)
protectedvirtual

Creates lists of crops.

Reimplemented from OptimisingFarm.

Definition at line 5574 of file farm.cpp.

5574  {
5575  OptimisingFarm::createVariableCrops(a_foobar);
5576  createFodderCrops(a_foobar);
5577 }

References createFodderCrops(), and OptimisingFarm::createVariableCrops().

◆ createFodderCrops()

void AnimalFarm::createFodderCrops ( int  a_foobar)
protected

Creates a list of pointers to all fodder crops.

Creates a vector of pointers to variable fodder crops (those fixed excluded!).

Definition at line 5596 of file farm.cpp.

5596  {
5599  int n = (int)m_crops.size();
5600  for (int i=0; i < n; ++i) {
5601  int crop_type=(cfg_OptimiseBedriftsmodelCrops.value())? (int)m_crops[i]->m_cropType : (int)m_crops[i]->m_cropType_almass;
5602  int index = a_foobar*m_farmType + crop_type;
5603  if(m_OurManager->pm_data->Get_fodder(index)){ //if the crop is a fodder crop...
5604  if(!(m_OurManager->pm_data->Get_fixed(index))){ //check if it is not fixed and attach it to the list
5605  CropSort cs={0., m_crops[i]};
5606  m_fodderCrops.push_back(cs);
5607  }
5608  }
5609  }
5610 }

References cfg_OptimiseBedriftsmodelCrops, DataForOptimisation::Get_fixed(), DataForOptimisation::Get_fodder(), OptimisingFarm::m_crops, OptimisingFarm::m_farmType, m_fodderCrops, Farm::m_OurManager, FarmManager::pm_data, and CfgBool::value().

Referenced by createCropsLists().

◆ decreaseCrops()

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

Decreases area of cropsToDecrease by howMuchToDecrease.

Function decreases area of one or more crops from the list given as a first argument.The total area subtracted from the crops in the list is equal to the value of the second argument. In case an area of a fodder crop is decreased, the m_totalFUgrown is decreased and the totalFUt is increased by the amount of fodder corresponding to the removed area of a given fodder crop.

Reimplemented from OptimisingFarm.

Definition at line 7931 of file farm.cpp.

7931  {
7936  for(int j=(int)cropsToDecrease.size()-1; howMuchToDecrease>0 && j>=0; j--){ //start with the worst
7937  double areaCrop = cropsToDecrease[j].crop->m_areaPercent;
7938  double areaBefore = areaCrop;
7939  double rotMinCrop = cropsToDecrease[j].crop->m_rotationMin;
7940  if(areaCrop - howMuchToDecrease >= rotMinCrop){
7941  areaCrop -= howMuchToDecrease;
7942  howMuchToDecrease = 0; //finito
7943  }
7944  else{
7945  howMuchToDecrease -= areaCrop - rotMinCrop;
7946  areaCrop = rotMinCrop;
7947  }
7948  cropsToDecrease[j].crop->m_areaPercent = areaCrop;
7949  cropsToDecrease[j].crop->m_areaVariable = areaCrop - rotMinCrop;
7950 
7951  if(areaCrop < areaBefore){
7952  int index = (cfg_OptimiseBedriftsmodelCrops.value())? toc_Foobar*m_farmType + cropsToDecrease[j].crop->m_cropType : tov_Undefined*m_farmType + cropsToDecrease[j].crop->m_cropType_almass;
7953  bool fodder = m_OurManager->pm_data->Get_fodder(index);
7954  if(fodder){ //this is a fodder crop - so you need to buy more fodder (totalFUt)
7955  double resp = cropsToDecrease[j].crop->m_resp;
7956  double loss = cropsToDecrease[j].crop->m_totalLoss;
7957  double FUKey = m_OurManager->pm_data->Get_FUKey(index);
7958  double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
7959  double changeFU = (areaBefore - areaCrop) * m_totalArea/100 * FUha; //positive number
7960  m_totalFUt += changeFU;
7961  m_totalFUgrown -= changeFU;
7962  }
7963  }
7964  }
7965 }

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

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

◆ determineAreas()

void AnimalFarm::determineAreas ( int  a_foobar)
protectedvirtual

Determines areas of variable crops.

Animal farm version of the determineAreas function. In case of some farms (i.e. cattle farms) the sum of maximum allowed areas of non-fodder crops does not reach 100%, therefore it is necessary to introduce a virtual crop (AnimalFarm::m_fakeCrop)to 'fill' the area til 100%. This virtual crop is substituted by fodder crops in AnimalFarm::determineFodderAreas function.

Reimplemented from OptimisingFarm.

Definition at line 6373 of file farm.cpp.

6373  {
6378  OptimisingFarm::determineAreas(a_foobar);
6379 
6380 /*If after this loop area assigned is < 100%, this means that the sum of the maximum allowed areas of non-fodder crops doesn't reach 100%;
6381 in such case introduce a fake crop to fill up the space till 100% (temporarily - until the determineFodderAreas function is called).*/
6382 
6383  m_fakeCropTest=false;
6384  if(m_assigned<100){ //use virtual 'fake crop'
6385  m_fakeCropTest = true;
6386  m_grownVariableCrops.push_back(m_fakeCrop); //append at the end (it is - it must be - the least profitable crop); this list is used in the determineFodderAreas function
6387  double areaP = 100-m_assigned;
6388  m_fakeCrop->m_GM = -1000000;
6389  m_fakeCrop->m_rotationMax = 100;
6390  m_fakeCrop->m_rotationMin = 0;
6391  m_fakeCrop->m_areaPercent = areaP;
6392  m_fakeCrop->m_areaVariable = areaP;
6393  m_assigned += areaP;
6394  }
6395 
6396  sortCrops(m_fodderCrops, "Savings"); //order fodder crops from the highest to the lowest savings resulting from growing a fodder crop - in relation to purchased fodder
6397  randomizeCropList(m_fodderCrops, "Savings"); //shuffles elements of the list with equal Savings
6398 
6399  sortCrops(m_variableCrops, "GM_Savings"); //has to be done before restrictions, but only for animal farms.
6400  randomizeCropList(m_variableCrops, "GM_Savings"); //shuffles elements of the list with equal GM_Savings. Fodder crops have their savings saved under GM_Savings, non-fodder - GM.
6401 
6402  correctFodderDemand(a_foobar); //correct demand for min areas and fixed crops
6403  determineFodderAreas(a_foobar);
6404 }

References correctFodderDemand(), OptimisingFarm::determineAreas(), determineFodderAreas(), CropOptimised::m_areaPercent, CropOptimised::m_areaVariable, OptimisingFarm::m_assigned, m_fakeCrop, m_fakeCropTest, m_fodderCrops, CropOptimised::m_GM, OptimisingFarm::m_grownVariableCrops, CropOptimised::m_rotationMax, CropOptimised::m_rotationMin, OptimisingFarm::m_variableCrops, OptimisingFarm::randomizeCropList(), and OptimisingFarm::sortCrops().

◆ determineFodderAreas()

void AnimalFarm::determineFodderAreas ( int  a_foobar)
protected

Determines areas of fodder crops and corrects areas of non-fodder crops.

First, it calls a function determining areas for fodder that has to be grown to fulfill the condition on min. requirement of own fodder production.

Next, the function chooses the most profitable alternative of covering the remaining fodder demand: purchasing fodder, growing fodder crops, or a mix of these two. In case any fodder crops are grown (above their minimum area), one or more of the variable crops' areas has to be corrected (decreased).

The general structure of the part of the function determining whether to grow fodder, buy it or mix the two: The outer for-loop goes through fodder crops until the total fodder demand is zero � and it starts with the crop with highest savings (the best one). At the beginning it checks if the fodder crop has reached its max rotation area. The inner for-loop goes through all non-fodder variable crops that after they were assigned area had an area above area minimum (there�s no point in checking other crops � their areas cannot be decreased). It starts with the variable crop with the lowest GM (the worst one) and the condition in the loop is a Boolean value which turns to true once a current fodder crop reached its area max. Then the outer loop takes the next best fodder crop.

In some cases (happens when the non-fodder crops are assigned areas according to the rules from the Bedriftsmodel - i.e. using the maximum rotations) even when the m_totalFUdemand is covered in 100% by fodder crops, there is still a virtual (non-fodder) crop present at a farm (m_fakeCrop). In such case this virtual crop has to be substituted by fodder crops and the total fodder production is higher than the total fodder demand (m_totalFUdemand).

Definition at line 7619 of file farm.cpp.

7619  {
7620 
7642 //1. assigning area to fodder crops in order to cover the min fodder production
7643  if(!cash_crops_allowed) determineMinFodder(a_foobar);
7644 
7645 //2. now the choice - produce or purchase fodder
7646 
7647  m_totalFUt=0;
7648 
7649 
7650  //go through fodder crops - start with the one with max savings. Check if it reached its max area (could have happened in the previous step)
7651 
7652 for(int p=0; m_totalFUdemand>0 && p<(int)m_fodderCrops.size(); p++){ //outer for loop - fodder crops;
7653 
7654  double rotationMax = m_fodderCrops[p].crop->m_rotationMax;
7655  double areaFodder = m_fodderCrops[p].crop->m_areaPercent;
7656  if(areaFodder < rotationMax){ //if not -> go to the next fodder crop
7657  double savings = m_fodderCrops[p].crop->m_savings;
7658  bool assigningFinished = false; //changed to true when a fodder crop reaches rotationMax
7659 
7660  int v = (int)m_grownVariableCrops.size()-1;
7661  double minGM = 1000000; //set it high so that if there are no grown var crops - we go directly to the fodder trade code (as savings are not > minGM)
7662  do{ //inner loop; normal crops; starts with the crop with the lowest GM;
7663  if(v>=0){
7664  minGM = m_grownVariableCrops[v]->m_GM;
7665  }
7666  if(savings > minGM){ //compare savings to GM of the worst 'available' normal crop - which is currently planted and have areaVariable>0
7667  double areaVariable = m_grownVariableCrops[v]->m_areaVariable;
7668  int index = (cfg_OptimiseBedriftsmodelCrops.value())? a_foobar*m_farmType + m_fodderCrops[p].crop->m_cropType : a_foobar*m_farmType + m_fodderCrops[p].crop->m_cropType_almass;
7669  double FUKey = m_OurManager->pm_data->Get_FUKey(index);//if it is not a fodder crop, key=0
7670  double resp = m_fodderCrops[p].crop->m_resp;
7671  double loss = m_fodderCrops[p].crop->m_totalLoss;
7672  double FUha = resp*(1-loss/100)*FUKey;
7673  double haNeeded = m_totalFUdemand/FUha;
7674  double percNeeded = haNeeded*100/m_totalArea;
7675 
7676  if(percNeeded <= rotationMax - areaFodder){//you can plant as much as need of fodder crop, but check if there is enough space in the normal crop
7677  if(percNeeded <= areaVariable){//if so, just plant as much as you need of this one fodder crop and cut the normal crop by percNeeded
7678  areaFodder += percNeeded; //increase the area (not just assign!)
7679  m_totalFUdemand = 0; //finish outer loop
7680  m_totalFUgrown += percNeeded*FUha*m_totalArea/100;
7681  areaVariable -= percNeeded;
7682  assigningFinished = true; //finish inner loop
7683  }
7684  else{//you can plant fodder crop on an area of a normal crop and then check with the next normal crop
7685  areaFodder += areaVariable; //increase by the whole 'available' area of a normal crop
7686  m_totalFUdemand -= FUha*areaVariable*m_totalArea/100; //update fodder demand
7687  m_totalFUgrown += areaVariable*FUha*m_totalArea/100;
7688  areaVariable = 0;
7689  }
7690  }
7691  else{//this fodder crop will not cover all the needs; will have to check the next one
7692  if(rotationMax - areaFodder <= areaVariable){//if so, just plant as much as you need of this one fodder crop and cut the normal crop by...
7693  areaVariable -= rotationMax-areaFodder;
7694  m_totalFUgrown += (rotationMax-areaFodder)*FUha*m_totalArea/100;
7695  m_totalFUdemand -= FUha*(rotationMax-areaFodder)*m_totalArea/100;
7696  areaFodder = rotationMax; //max
7697  assigningFinished = true;
7698  //finish inner loop-you have to take the next fodder crop
7699  }
7700  else{//you can plant fodder crop on an area of a normal crop and then check with the next normal crop
7701  areaFodder += areaVariable; //increase by the whole 'available' area of a normal crop
7702  m_totalFUdemand -= FUha*areaVariable*m_totalArea/100;
7703  m_totalFUgrown += areaVariable*FUha*m_totalArea/100;
7704  areaVariable = 0;
7705  //whole replaced by a fodder crop
7706  }
7707  }
7708  double areaMin = m_grownVariableCrops[v]->m_rotationMin;
7709  double areaPer = areaMin + areaVariable;
7710  m_grownVariableCrops[v]->m_areaPercent = areaPer;
7711  m_grownVariableCrops[v]->m_areaVariable = areaVariable;
7712 
7713  }
7714  else{//buy all the remaining fodder demand
7715  m_totalFUt = m_totalFUdemand; //demand is already updated for fodder from fixed crops and min areas
7716  m_totalFUdemand = 0; //finish outer loop
7717  assigningFinished = true; //finish inner loop
7718  }
7719  v--;
7720  }while (assigningFinished==false && v>=0);//inner loop (normal crops)
7721 
7722  m_fodderCrops[p].crop->m_areaPercent = areaFodder;//update fodder crop - after the inner loop
7723 
7724  if(assigningFinished==false){ //loop was stopped by the condition->no more space on normal crops available
7725  //there's no more space on normal crops-have to buy the remaining totalFUdemand
7726  m_totalFUt += m_totalFUdemand;
7727  }
7728  }
7729 }//outer for-loop (fodder crops)
7730 
7731 
7732 if(m_totalFUdemand > 0){ //added 30.01 - for some farms the condition 'if(areaFodder<rotationMax)' is never fulfilled, so the inner loop will never run
7733  m_totalFUt = m_totalFUdemand;
7734  m_totalFUdemand = 0;
7735 }
7736 
7737 if(m_fakeCropTest==true){ //only if it was used in determineAreas - check if it is >0
7738  //check if the fake crop is still there - if so, substitute it with fodder crops
7739  int s = (int)m_grownVariableCrops.size()-1;
7740  double areaFakeCrop = m_grownVariableCrops[s]->m_areaPercent;
7741  if(areaFakeCrop > 0){
7742  increaseCrops(m_fodderCrops, areaFakeCrop);
7743  m_grownVariableCrops[s]->m_areaPercent = areaFakeCrop; //sets fake crop's area at 0.
7744  }
7745  //remove the fake crop from the grownVariable crops vector
7746  m_grownVariableCrops.erase(m_grownVariableCrops.begin() + s);
7747 }
7748 
7749 }// end of determineFodderAreas

References cash_crops_allowed, cfg_OptimiseBedriftsmodelCrops, determineMinFodder(), DataForOptimisation::Get_FUKey(), increaseCrops(), m_fakeCropTest, OptimisingFarm::m_farmType, m_fodderCrops, OptimisingFarm::m_grownVariableCrops, Farm::m_OurManager, OptimisingFarm::m_totalArea, OptimisingFarm::m_totalFUdemand, OptimisingFarm::m_totalFUgrown, OptimisingFarm::m_totalFUt, FarmManager::pm_data, and CfgBool::value().

Referenced by determineAreas().

◆ determineMinFodder()

void AnimalFarm::determineMinFodder ( int  a_foobar)
protected

Covers the min. required fodder production for animal farms.

Function assigning area to fodder crops in order to cover the min fodder production if it is not covered by the fodder from fixed crops and min. areas of variable crops.

Definition at line 7541 of file farm.cpp.

7541  {
7544  double areaAssignedToFodder=0; //holds the value of area that has to be grown to cover the min fodder production requirement
7545  if(m_fodderToProduce > 0){
7546  double available=0; //area of normal (non-fodder) crops available to substitute with fodder crops
7547  for(int i=0; i<(int)m_grownVariableCrops.size(); i++){
7548  double areaVariableCrop = m_grownVariableCrops[i]->m_areaVariable;
7549  available += areaVariableCrop;
7550  }
7551 
7552  for(int i=0; available>0 && i<(int)m_fodderCrops.size() && m_fodderToProduce > 0 ; i++){// if so, more has to be produced (than it is already-from min areas and fixed crops)
7553  int index = (cfg_OptimiseBedriftsmodelCrops.value())? a_foobar*m_farmType + + m_fodderCrops[i].crop->m_cropType : a_foobar*m_farmType + + m_fodderCrops[i].crop->m_cropType_almass;
7554  double rotationMax = m_fodderCrops[i].crop->m_rotationMax;
7555  double area = m_fodderCrops[i].crop->m_areaPercent; //fodder crop's area
7556  double areaBefore = area; //this is positive if areaMin>0, so save it
7557  double FUKey = m_OurManager->pm_data->Get_FUKey(index); //if it is not a fodder crop, key=0; number of FU per hkg of a crop
7558  double resp = m_fodderCrops[i].crop->m_resp;
7559  double loss = m_fodderCrops[i].crop->m_totalLoss;
7560  double FUha = resp * (1-loss/100) * FUKey;
7561  double haNeeded = m_fodderToProduce/FUha;
7562  double percNeeded = haNeeded*100/m_totalArea;
7563  if(percNeeded <= rotationMax - area){ //area might be positive! (min area)
7564  if(percNeeded <= available){
7565  area += percNeeded; //the end, fodderToProduce will be 0.
7566  available -= percNeeded;
7567  }
7568  else{
7569  area+=available; //so we can't grow any more fodder - no space left!
7570  available=0;
7571  }
7572  }
7573  else{
7574  if(rotationMax-area >= available){
7575  area += available;
7576  available=0; //no space left
7577  }
7578  else{
7579  available -= rotationMax-area;
7580  area = rotationMax;
7581  }
7582  }
7583  m_fodderCrops[i].crop->m_areaPercent = area;
7584  double Funits = FUha * (area-areaBefore) * m_totalArea/100;
7585  m_fodderToProduce -= Funits; //update fodderToProduce; in 1st case - it's now = 0.
7586  m_totalFUdemand -= Funits; //update the total demand as well!
7587  m_totalFUgrown += Funits; //update the amount of grown fodder units
7588  areaAssignedToFodder += (area-areaBefore);
7589 
7590  }
7591  if(m_fodderToProduce>0.1){
7592  //restriction broken! impossible to produce the min amount of fodder - send a message, but don't stop.
7593  char index[ 20 ];
7594  sprintf( index, "%d", m_almass_no);
7595  g_msg->Warn( WARN_BUG, "AnimalFarm::determineMinFodder(): impossible to cover the min. fodder prod., farm no: ", index );
7596  //exit( 1 );
7597  }
7598  //decreasing area of variable crops that has just been assigned to fodder crops
7599  //need to create a vector of type CropSort
7600  vector<CropSort>grownVarCrops_key;
7601  for(int g=0; g < (int)m_grownVariableCrops.size(); g++){
7602  CropSort gc = {0., m_grownVariableCrops[g]};
7603  grownVarCrops_key.push_back(gc);
7604  }
7605 
7606  OptimisingFarm::decreaseCrops(grownVarCrops_key, areaAssignedToFodder); //m_grownVariableCrops does not contain fodder crops-call optimising farms version. there might be here a fake crop; here use grownVarCrops_key - need CropSort type vector to use decreaseCrops;
7607  if(areaAssignedToFodder>0){
7608  //there is not enough space to grow fodder to cover the min required.
7609  char index[ 20 ];
7610  sprintf( index, "%d", m_almass_no);
7611  g_msg->Warn( WARN_BUG, "AnimalFarm::determineMinFodder(): not enough space to grow the min. fodder, farm no.: ", index );
7612  //exit( 1 );
7613 
7614  }
7615  }
7616 } //determineMinFodder

References cfg_OptimiseBedriftsmodelCrops, OptimisingFarm::decreaseCrops(), g_msg, DataForOptimisation::Get_FUKey(), OptimisingFarm::m_almass_no, OptimisingFarm::m_farmType, m_fodderCrops, m_fodderToProduce, OptimisingFarm::m_grownVariableCrops, Farm::m_OurManager, OptimisingFarm::m_totalArea, OptimisingFarm::m_totalFUdemand, OptimisingFarm::m_totalFUgrown, FarmManager::pm_data, CfgBool::value(), MapErrorMsg::Warn(), and WARN_BUG.

Referenced by determineFodderAreas().

◆ findFodderCropSavings()

void AnimalFarm::findFodderCropSavings ( )
protected

Determines the savings resulting from growing a fodder crop relative to purchasing fodder.

◆ increaseCrops()

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

Increases area of cropsToIncrease by howMuchToIncrease.

Function increases area of one or more crops from the list given as a first argument.The total area added to the crops in the list is equal to the value of the second argument. In case an area of a fodder crop is increased, the m_totalFUgrown is increased and the m_totalFUt is decreased by the amount of fodder corresponding to the added area of a given fodder crop.

Reimplemented from OptimisingFarm.

Definition at line 7874 of file farm.cpp.

7874  {
7879  for(int i=0; howMuchToIncrease>0 && i<(int)cropsToIncrease.size(); i++){
7880  double area = cropsToIncrease[i].crop->m_areaPercent;
7881  double areaBefore = area;
7882  double rotationMax = cropsToIncrease[i].crop->m_rotationMax;
7883  double rotMinCrop = cropsToIncrease[i].crop->m_rotationMin;
7884  if(area + howMuchToIncrease <= rotationMax){
7885  area += howMuchToIncrease; //finito
7886  howMuchToIncrease = 0;
7887  }
7888  else{
7889  howMuchToIncrease -= rotationMax-area;
7890  area = rotationMax;
7891  }
7892  cropsToIncrease[i].crop->m_areaPercent = area;
7893  cropsToIncrease[i].crop->m_areaVariable = area - rotMinCrop;
7894 
7895  //checking if area has changed
7896  if(area > areaBefore){
7897  int index = (cfg_OptimiseBedriftsmodelCrops.value())? toc_Foobar*m_farmType + cropsToIncrease[i].crop->m_cropType : tov_Undefined*m_farmType + cropsToIncrease[i].crop->m_cropType_almass;
7898  bool fodder = m_OurManager->pm_data->Get_fodder(index);
7899  if(fodder){ //this is a fodder crop - so you need to buy less fodder (totalFUt)
7900  double resp = cropsToIncrease[i].crop->m_resp;
7901  double loss = cropsToIncrease[i].crop->m_totalLoss;
7902  double FUKey = m_OurManager->pm_data->Get_FUKey(index);
7903  double FUha = resp * (1-loss/100) * FUKey; //[ha * hkg/ha * FU/hkg = FU]
7904  double changeFU = (area-areaBefore) * m_totalArea/100 * FUha; //positive
7905  m_totalFUt -= changeFU;
7906  m_totalFUgrown += changeFU;
7907  }
7908  }
7909  }
7910 }

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

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

Member Data Documentation

◆ cash_crops_allowed

bool AnimalFarm::cash_crops_allowed
protected

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

Definition at line 2397 of file farm.h.

Referenced by AnimalFarm(), determineFodderAreas(), and OptimisingCattleFarm::preventCashCrops().

◆ m_fakeCrop

CropOptimised* AnimalFarm::m_fakeCrop
protected

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.

Definition at line 2378 of file farm.h.

Referenced by AnimalFarm(), and determineAreas().

◆ m_fakeCropTest

bool AnimalFarm::m_fakeCropTest
protected

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

Definition at line 2384 of file farm.h.

Referenced by determineAreas(), and determineFodderAreas().

◆ m_fodderCrops

vector<CropSort> AnimalFarm::m_fodderCrops
protected

List of pointers to variable (non-fixed) fodder crops.

Definition at line 2386 of file farm.h.

Referenced by createFodderCrops(), determineAreas(), determineFodderAreas(), and determineMinFodder().

◆ m_fodderToProduce

double AnimalFarm::m_fodderToProduce
protected

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

Definition at line 2393 of file farm.h.

Referenced by correctFodderDemand(), and determineMinFodder().

◆ m_fodderToProduceBefore

double AnimalFarm::m_fodderToProduceBefore
protected

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

Definition at line 2395 of file farm.h.

Referenced by correctFodderDemand().

◆ m_totalFodderToProduce

double AnimalFarm::m_totalFodderToProduce
protected

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

Definition at line 2391 of file farm.h.

Referenced by correctFodderDemand().

The documentation for this class was generated from the following files:
AnimalFarm::correctFodderDemand
void correctFodderDemand(int a_foobar)
Determines how much fodder is produced from fixed crops and min. areas of variable crops.
Definition: farm.cpp:7488
toof_Pig
Definition: farm.h:282
OptimisingFarm::m_totalArea
double m_totalArea
Total area of a farm. A sum of initial crop areas (if in bedriftsmodel, i.e. original farm optimizati...
Definition: farm.h:2224
OptimisingFarm::m_grownVariableCrops
vector< CropOptimised * > m_grownVariableCrops
Vector of pointers to variable crops that are grown on area larger than areaMin (after determineAreas...
Definition: farm.h:2192
OptimisingFarm::m_almass_no
int m_almass_no
Farm's almass number.
Definition: farm.h:2220
DataForOptimisation::Get_fodder
bool Get_fodder(int i)
Definition: farm.h:643
AnimalFarm::increaseCrops
virtual void increaseCrops(vector< CropSort >cropsToIncrease, double &howMuchToIncrease)
Increases area of cropsToIncrease by howMuchToIncrease.
Definition: farm.cpp:7874
tov_Undefined
Definition: tov_declaration.h:114
OptimisingFarm::determineAreas
virtual void determineAreas(int a_foobar)
Determines areas of variable crops.
Definition: farm.cpp:6304
AnimalFarm::determineFodderAreas
void determineFodderAreas(int a_foobar)
Determines areas of fodder crops and corrects areas of non-fodder crops.
Definition: farm.cpp:7619
DataForOptimisation::Get_winterMax
int Get_winterMax(int i)
Definition: farm.h:614
DataForOptimisation::Get_FUKey
double Get_FUKey(int i)
Definition: farm.h:645
WARN_BUG
Definition: maperrormsg.h:34
AnimalFarm::m_fakeCrop
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 det...
Definition: farm.h:2378
CropOptimised::m_GM
double m_GM
Value of gross margin for a crop (m_income_ha - m_costs_ha) [DKK/ha].
Definition: farm.h:1689
OptimisingFarm::OptimisingFarm
OptimisingFarm(FarmManager *a_myfarmmanager, int a_No)
The constructor.
Definition: farm.cpp:5153
AnimalFarm::m_fodderToProduceBefore
double m_fodderToProduceBefore
Fodder that has to be produced to fulfill the min. fodder production restriction at the beginning of ...
Definition: farm.h:2395
g_msg
class MapErrorMsg * g_msg
Definition: maperrormsg.cpp:41
AnimalFarm::determineMinFodder
void determineMinFodder(int a_foobar)
Covers the min. required fodder production for animal farms.
Definition: farm.cpp:7541
cfg_Min_fodder_prod_cattle
CfgFloat cfg_Min_fodder_prod_cattle("MIN_FODDER_PROD_CATTLE", CFG_CUSTOM, 35)
A parameter setting the minimum proportion of fodder demand that has to be supplied from own fodder p...
CropOptimised
A class for storing all parameters and results of crop optimisation.
Definition: farm.h:1634
OptimisingFarm::decreaseCrops
virtual void decreaseCrops(vector< CropSort >cropsToDecrease, double &howMuchToDecrease)
Decreases area of a crops by a specified number.
Definition: farm.cpp:7912
OptimisingFarm::m_totalFUgrown
double m_totalFUgrown
Fodder grown, i.e. obtained from growing fodder crops. [fodder units].
Definition: farm.h:2240
OptimisingFarm::createVariableCrops
void createVariableCrops(int a_foobar)
Creates a list of pointers to all variable crops included in the optimisation and a list of pointers ...
Definition: farm.cpp:5579
AnimalFarm::m_fodderToProduce
double m_fodderToProduce
Fodder that has to be produced to fulfill the min. fodder production restriction at the end of a year...
Definition: farm.h:2393
AnimalFarm::cash_crops_allowed
bool cash_crops_allowed
Sets to true if cash crops are allowed. True by default.
Definition: farm.h:2397
OptimisingFarm::findCropByName
CropOptimised * findCropByName(string crop_name)
Returns a pointer to a crop whose name is specified as the argument (bedriftsmodel,...
Definition: farm.cpp:7762
OptimisingFarm::m_crops
vector< CropOptimised * > m_crops
Vector of pointers to all crops.
Definition: farm.h:2183
AnimalFarm::createFodderCrops
void createFodderCrops(int a_foobar)
Creates a list of pointers to all fodder crops.
Definition: farm.cpp:5596
MapErrorMsg::Warn
void Warn(MapErrorState a_level, std::string a_msg1, std::string a_msg2)
Definition: maperrormsg.cpp:59
AnimalFarm::m_fakeCropTest
bool m_fakeCropTest
Set to true if the fake crop is present after determineAreas function.
Definition: farm.h:2384
OptimisingFarm::sortCrops
void sortCrops(vector< CropSort > &cropsToSort, string sortingKey)
Sorts structs of type CropSort.
Definition: farm.cpp:7788
OptimisingFarm::m_totalFUdemand
double m_totalFUdemand
Farm's total demand for fodder (it is covered by growing fodder crops and/or purchasing fodder and th...
Definition: farm.h:2236
CfgFloat::value
double value(void)
Definition: configurator.h:118
cfg_Min_fodder_prod_pig
CfgFloat cfg_Min_fodder_prod_pig("MIN_FODDER_PROD_PIG", CFG_CUSTOM, 20)
A parameter setting the minimum proportion of fodder demand that has to be supplied from own fodder p...
CropOptimised::m_areaPercent
double m_areaPercent
Area of a crop in percent of a farm's total area [%].
Definition: farm.h:1695
OptimisingFarm::m_winterCrops
vector< CropSort > m_winterCrops
Vector of structs containing pointers to winter crops.
Definition: farm.h:2198
OptimisingFarm::m_variableCrops2
vector< CropSort > m_variableCrops2
Vector of structs containing pointers to crops which are not fixed and: in case of the winter rotatio...
Definition: farm.h:2190
CropOptimised::m_rotationMin
double m_rotationMin
Minimum area in percent of farm's arable area for a given crop (depends on a farm size,...
Definition: farm.h:1652
OptimisingFarm::m_fixedCrops
vector< CropOptimised * > m_fixedCrops
Vector of pointers to fixed crops.
Definition: farm.h:2194
Farm::m_OurManager
FarmManager * m_OurManager
Pointer to the FarmManager.
Definition: farm.h:935
OptimisingFarm::m_variableCrops
vector< CropSort > m_variableCrops
Vector of structs containing pointers to crops which are not fixed.
Definition: farm.h:2185
OptimisingFarm::randomizeCropList
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 p...
Definition: farm.cpp:7811
toc_Foobar
Definition: farm.h:367
AnimalFarm::m_totalFodderToProduce
double m_totalFodderToProduce
Fodder that has to be produced by a farm to fulfill the min. fodder production restriction....
Definition: farm.h:2391
OptimisingFarm::m_rotationCrops
vector< CropSort > m_rotationCrops
Vector of structs containing pointers to (winter) rotation crops.
Definition: farm.h:2196
FarmManager::pm_data
DataForOptimisation * pm_data
Pointer to the DataForOptimisation.
Definition: farm.h:1876
OptimisingFarm::m_farmType
TTypesOfOptFarms m_farmType
Farm's type (cattle, pig, plant, other).
Definition: farm.h:2210
AnimalFarm::m_fodderCrops
vector< CropSort > m_fodderCrops
List of pointers to variable (non-fixed) fodder crops.
Definition: farm.h:2386
OptimisingFarm::m_assigned
double m_assigned
Variable holding a value of area already reserved for certain crops at a farm. [0-100%].
Definition: farm.h:2242
DataForOptimisation::Get_fixed
bool Get_fixed(int i)
Definition: farm.h:638
OptimisingFarm::findCropByName_almass
CropOptimised * findCropByName_almass(string crop_name)
Returns a pointer to almass crop whose name is specified as the argument (ALMaSS crops mode).
Definition: farm.cpp:7770
CropOptimised::m_areaVariable
double m_areaVariable
Area of a crop that can be changed when checking for restrictions (=m_areaPercent - m_rotationMin) [%...
Definition: farm.h:1697
cfg_OptimiseBedriftsmodelCrops
CfgBool cfg_OptimiseBedriftsmodelCrops("OPTIMISE_BEDRIFTSMODEL_CROPS", CFG_CUSTOM, false)
If set to true, the original farm optimisation model's crop set is used in the farmer decision making...
CfgBool::value
bool value(void)
Definition: configurator.h:135
CropOptimised::m_rotationMax
double m_rotationMax
Maximum area in percent of farm's arable area for a given crop (depends on a farm size,...
Definition: farm.h:1650
OptimisingFarm::m_totalFUt
double m_totalFUt
Fodder from trade (has to be purchased). [fodder units].
Definition: farm.h:2238
AnimalFarm::decreaseCrops
virtual void decreaseCrops(vector< CropSort >cropsToDecrease, double &howMuchToDecrease)
Decreases area of cropsToDecrease by howMuchToDecrease.
Definition: farm.cpp:7931