Esempio n. 1
0
        private void OnWFAnimalMilking(object sender, EventArgs e)
        {
            if (ProportionToRemove > 0)
            {
                // get dry breeders
                RuminantHerd          ruminantHerd = Resources.RuminantHerd();
                List <RuminantFemale> herd         = ruminantHerd.Herd.Where(a => a.BreedParams.Name == HerdName & a.Gender == Sex.Female).Cast <RuminantFemale>().ToList();
                if (SellFromManagedPaddock)
                {
                    // in sepecified paddock
                    herd = herd.Where(a => a.Location == PaddockName).ToList();
                }

                TMyRandom randomGenerator = new TMyRandom(10);

                // get dry breeders from females
                foreach (RuminantFemale female in herd.Where(a => a.Age - a.AgeAtLastBirth >= MonthsSinceBirth & a.PreviousConceptionRate >= MinimumConceptionBeforeSell & a.AgeAtLastBirth > 0))
                {
                    if (randomGenerator.RandNo <= ProportionToRemove)
                    {
                        // flag female ready to transport.
                        female.SaleFlag = Common.HerdChangeReason.DryBreederSale;
                    }
                }
            }
        }
Esempio n. 2
0
        private void OnWFRequestFeed(object sender, EventArgs e)
        {
            if (labourLimiter > 0)
            {
                RuminantHerd    ruminantHerd = Resources.RuminantHerd();
                List <Ruminant> herd         = ruminantHerd.Herd;

                if (herd == null && herd.Count == 0)
                {
                    return;
                }

                // get month from clock
                int month = Clock.Today.Month;

                // get list from filters
                foreach (var child in this.Children)
                {
                    if (child.GetType() == typeof(RuminantFilterGroup))
                    {
                        foreach (Ruminant ind in herd.Filter(child as RuminantFilterGroup))
                        {
                            RuminantFeedRequest freqest = new RuminantFeedRequest();
                            freqest.FeedActivity = this;
                            freqest.Requestor    = ind;
                            freqest.Amount       = 0;
                            switch (FeedStyle)
                            {
                            case RuminantFeedActivityTypes.SpecifiedAmount:
                                freqest.Amount = (child as RuminantFilterGroup).MonthlyValues[month - 1];                                         // * ind.Number;
                                break;

                            case RuminantFeedActivityTypes.ProportionOfWeight:
                                freqest.Amount = (child as RuminantFilterGroup).MonthlyValues[month - 1] * ind.Weight;                                         // * ind.Number;
                                break;

                            case RuminantFeedActivityTypes.ProportionOfPotentialIntake:
                                freqest.Amount = (child as RuminantFilterGroup).MonthlyValues[month - 1] * ind.PotentialIntake;                                         // * ind.Number;
                                break;

                            case RuminantFeedActivityTypes.ProportionOfRemainingIntakeRequired:
                                freqest.Amount = (child as RuminantFilterGroup).MonthlyValues[month - 1] * (ind.PotentialIntake - ind.Intake);                                         // * ind.Number;
                                break;

                            default:
                                break;
                            }
                            freqest.Amount *= labourLimiter;
                            FoodSource.Remove(freqest);
                        }
                    }
                }
            }
        }
Esempio n. 3
0
        private void OnWFAgeResources(object sender, EventArgs e)
        {
            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd;

            // grow all individuals
            foreach (Ruminant ind in herd)
            {
                ind.Age++;
            }
        }
Esempio n. 4
0
        private void OnWFRequestFeed(object sender, EventArgs e)
        {
            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd;

            IResourceType grazeStoreType = null;

            if (FeedArbitratorName != "")
            {
                grazeStoreType = Arbitrators.GetByName(FeedArbitratorName) as IResourceType;
            }

            // for each paddock defined in PastureActivityManage
            foreach (PastureActivityManage pasture in Activities.Children.Where(a => a.GetType() == typeof(PastureActivityManage)))
            {
                if (FeedArbitratorName == "")
                {
                    grazeStoreType = pasture.FeedType;
                }

                // create feeding activity for this pasture
                RuminantActivityGraze activity = new RuminantActivityGraze();
                activity.FeedPriority = this.FeedPriority;
                activity.FeedType     = pasture.FeedType;
                activity.HoursGrazed  = this.HoursGrazed;
                activity.Name         = String.Format("Graze {0}", pasture.FeedType.Name);

                // calculate kg per ha available
                double kgPerHa = pasture.FeedType.Amount / pasture.Area;

                if (pasture.FeedType.Amount > 0)
                {
                    // get list of all Ruminants in this paddock
                    foreach (Ruminant ind in herd.Where(a => a.Location == pasture.Name))
                    {
                        RuminantFeedRequest freqest = new RuminantFeedRequest();
                        freqest.FeedActivity = activity;
                        freqest.Requestor    = ind;

                        // Reduce potential intake based on pasture quality for the proportion consumed.


                        // calculate intake from potential modified by pasture availability and hours grazed
                        freqest.Amount = ind.PotentialIntake * (1 - Math.Exp(-ind.BreedParams.IntakeCoefficientBiomass * kgPerHa)) * (HoursGrazed / 8);
                        grazeStoreType.Remove(freqest);
                    }
                }
            }
        }
Esempio n. 5
0
        private void OnEndOfMonth(object sender, EventArgs e)
        {
            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd;

            // group by breed
            foreach (var breedGroup in herd.GroupBy(a => a.Breed))
            {
                // group by herd
                foreach (var herdGroup in breedGroup.GroupBy(a => a.HerdName))
                {
                    // group by sex
                    foreach (var sexGroup in herdGroup.GroupBy(a => a.Gender))
                    {
                        //// sucklings
                        //var sucklings = sexGroup.Where(a => !a.Weaned);
                        //if(sucklings.Count() > 0)
                        //{
                        //}

                        // weaned
                        foreach (var ageGroup in sexGroup.OrderBy(a => a.Age).GroupBy(a => Math.Truncate(a.Age / 12.0)))
                        {
                            ReportDetails                   = new HerdReportItemGeneratedEventArgs();
                            ReportDetails.Breed             = breedGroup.Key;
                            ReportDetails.Herd              = herdGroup.Key;
                            ReportDetails.Age               = Convert.ToInt32(ageGroup.Key);
                            ReportDetails.Sex               = sexGroup.Key.ToString().Substring(0, 1);
                            ReportDetails.Number            = ageGroup.Sum(a => a.Number);
                            ReportDetails.AverageWeight     = ageGroup.Average(a => a.Weight);
                            ReportDetails.AverageWeightGain = ageGroup.Average(a => a.WeightGain);
                            ReportDetails.AverageIntake     = ageGroup.Average(a => (a.Intake));                         //now daily/30.4;
                            ReportDetails.AdultEquivalents  = ageGroup.Sum(a => a.AdultEquivalent);
                            if (sexGroup.Key == Sex.Female)
                            {
                                ReportDetails.NumberPregnant = ageGroup.Cast <RuminantFemale>().Where(a => a.IsPregnant).Count();
                                ReportDetails.NumberOfBirths = ageGroup.Cast <RuminantFemale>().Where(a => a.BirthDue).Sum(a => a.SucklingOffspring.Count());
                            }
                            else
                            {
                                ReportDetails.NumberPregnant = 0;
                                ReportDetails.NumberOfBirths = 0;
                            }
                            ReportItemGenerated(ReportDetails);
                        }
                    }
                }
            }
        }
Esempio n. 6
0
        private void OnWFAnimalBuy(object sender, EventArgs e)
        {
            RuminantHerd ruminantHerd = Resources.RuminantHerd();

            Finance     Accounts    = Resources.FinanceResource() as Finance;
            FinanceType bankAccount = Accounts.GetFirst();

            var newRequests = ruminantHerd.PurchaseIndividuals.Where(a => a.BreedParams.Breed == BreedName).ToList();

            foreach (var newgroup in newRequests.GroupBy(a => a.SaleFlag))
            {
                double fundsAvailable = 100000000;
                if (bankAccount != null)
                {
                    fundsAvailable = bankAccount.FundsAvailable;
                }
                double cost = 0;
                foreach (var newind in newgroup)
                {
                    double value = 0;
                    if (newgroup.Key == Common.HerdChangeReason.SirePurchase)
                    {
                        value = BreedingSirePrice;
                    }
                    else
                    {
                        RuminantValue getvalue = PriceList.Where(a => a.Age < newind.Age).OrderBy(a => a.Age).LastOrDefault();
                        value = getvalue.PurchaseValue * ((getvalue.Style == Common.PricingStyleType.perKg) ? newind.Weight : 1.0);
                    }
                    if (cost + value <= fundsAvailable)
                    {
                        ruminantHerd.AddRuminant(newind);
                        cost += value;
                    }
                    else
                    {
                        break;
                    }
                }
                if (bankAccount != null)
                {
                    bankAccount.Remove(cost, this.Name, newgroup.Key.ToString());
                }
            }
        }
Esempio n. 7
0
        private void OnWFPotentialIntake(object sender, EventArgs e)
        {
            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd;

            // Natural weaning takes place here before animals eat or take milk from mother.
            foreach (var ind in herd.Where(a => a.Weaned == false))
            {
                if (ind.Age >= ind.BreedParams.GestationLength + 1)
                {
                    ind.Wean();
                }
            }

            // Calculate potential intake and reset stores
            foreach (var ind in herd)
            {
                // reset tallies at start of the month
                ind.DietDryMatterDigestibility = 0;
                ind.PercentNOfIntake           = 0;
                ind.Intake     = 0;
                ind.MilkIntake = 0;
                CalculatePotentialIntake(ind);
            }

            // TODO: Future cohort based run may speed up simulation
            // Calculate by cohort method and assign values to individuals.
            // Need work out what grouping should be based on Name, Breed, Gender, Weight, Parity...
            // This approach will not currently work as individual may have individual weights and females may be in various states of breeding.
            //
            //var cohorts = herd.GroupBy(a => new { a.BreedParams.Breed, a.Gender, a.Age, lactating = (a.DryBreeder | a.Milk) });
            //foreach (var cohort in cohorts)
            //{
            //	CalculatePotentialIntake(cohort.FirstOrDefault());
            //	double potintake = cohort.FirstOrDefault().PotentialIntake;
            //	foreach (var ind in cohort)
            //	{
            //		ind.PotentialIntake = potintake;
            //	}
            //}
        }
Esempio n. 8
0
        private void Muster()
        {
            // get herd to muster
            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd;

            if (herd == null && herd.Count == 0)
            {
                return;
            }

            // get list from filters
            foreach (Ruminant ind in herd.Filter(this))
            {
                // set new location ID
                ind.Location = pasture.Name;

                // check if sucklings are to be moved with mother
                if (MoveSucklings)
                {
                    // if female
                    if (ind.GetType() == typeof(RuminantFemale))
                    {
                        RuminantFemale female = ind as RuminantFemale;
                        // check if mother with sucklings
                        if (female.SucklingOffspring.Count > 0)
                        {
                            foreach (var suckling in female.SucklingOffspring)
                            {
                                suckling.Location = pasture.Name;
                            }
                        }
                    }
                }
            }
        }
Esempio n. 9
0
        private void OnWFAnimalSell(object sender, EventArgs e)
        {
            RuminantHerd ruminantHerd = Resources.RuminantHerd();

            Finance     Accounts    = Resources.FinanceResource() as Finance;
            FinanceType bankAccount = Accounts.GetFirst();

            int    trucks     = 0;
            double saleValue  = 0;
            double saleWeight = 0;
            int    head       = 0;

            // get current untrucked list of animals flagged for sale
            List <Ruminant> herd = ruminantHerd.Herd.Where(a => a.SaleFlag != Common.HerdChangeReason.None & a.Breed == BreedName).OrderByDescending(a => a.Weight).ToList();

            // if sale herd > min loads before allowing sale
            if (herd.Select(a => a.Weight / 450.0).Sum() / Number450kgPerTruck >= MinimumTrucksBeforeSelling)
            {
                // while truck to fill
                while (herd.Select(a => a.Weight / 450.0).Sum() / Number450kgPerTruck > MinimumLoadBeforeSelling)
                {
                    bool nonloaded = true;
                    trucks++;
                    double load450kgs = 0;
                    // while truck below carrying capacity load individuals
                    foreach (var ind in herd)
                    {
                        if (load450kgs + (ind.Weight / 450.0) <= Number450kgPerTruck)
                        {
                            nonloaded = false;
                            head++;
                            load450kgs += ind.Weight / 450.0;
                            RuminantValue getvalue = PriceList.Where(a => a.Age < ind.Age).OrderBy(a => a.Age).LastOrDefault();
                            saleValue  += getvalue.SellValue * ((getvalue.Style == Common.PricingStyleType.perKg) ? ind.Weight : 1.0);
                            saleWeight += ind.Weight;
                            ruminantHerd.RemoveRuminant(ind);
                        }
                    }
                    if (nonloaded)
                    {
                        Summary.WriteWarning(this, String.Format("There was a problem loading the sale truck as sale individuals did not meet the loading criteria for breed {0}", BreedName));
                        break;
                    }
                    herd = ruminantHerd.Herd.Where(a => a.SaleFlag != Common.HerdChangeReason.None & a.Breed == BreedName).OrderByDescending(a => a.Weight).ToList();
                }

                if (trucks > 0 & bankAccount != null)
                {
                    // calculate transport costs
                    double transportCost = trucks * DistanceToMarket * CostPerKmTrucking;
                    bankAccount.Remove(transportCost, this.Name, "Transport");
                    // calculate MLA fees
                    double mlaCost = head * MLAFees;
                    bankAccount.Remove(mlaCost, this.Name, "R&DFee");
                    // calculate yard fees
                    double yardCost = head * YardFees;
                    bankAccount.Remove(yardCost, this.Name, "YardCosts");
                    // calculate commission
                    double commissionCost = saleValue * SalesCommission;
                    bankAccount.Remove(commissionCost, this.Name, "SalesCommission");

                    // add and remove from bank
                    bankAccount.Add(saleValue, this.Name, "Sales");
                }
            }
        }
Esempio n. 10
0
        /// <summary>
        /// Create the individual ruminant animals using the Cohort parameterisations.
        /// </summary>
        /// <returns></returns>
        public List <Ruminant> CreateIndividuals()
        {
            List <Ruminant> Individuals = new List <Ruminant>();

            IModel       parentNode = Apsim.Parent(this, typeof(IModel));
            RuminantType parent     = parentNode as RuminantType;

            // get Ruminant Herd resource for unique ids
            RuminantHerd ruminantHerd = Resources.RuminantHerd();

            parent = this.Parent as RuminantType;

            if (StartingNumber > 0)
            {
                //TODO: get random generator from global store with seed
                Random rand = new Random();
                for (int i = 1; i <= StartingNumber; i++)
                {
                    object ruminantBase = null;
                    if (this.Gender == Sex.Male)
                    {
                        ruminantBase = new RuminantMale();
                    }
                    else
                    {
                        ruminantBase = new RuminantFemale();
                    }

                    Ruminant ruminant = ruminantBase as Ruminant;

                    ruminant.ID          = ruminantHerd.NextUniqueID;
                    ruminant.BreedParams = parent;
                    ruminant.Breed       = parent.Breed;
                    ruminant.HerdName    = parent.Name;
                    ruminant.Gender      = Gender;
                    ruminant.Age         = StartingAge;
                    ruminant.SaleFlag    = Common.HerdChangeReason.None;
                    if (Suckling)
                    {
                        ruminant.SetUnweaned();
                    }

                    double u1            = rand.NextDouble();
                    double u2            = rand.NextDouble();
                    double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) *
                                           Math.Sin(2.0 * Math.PI * u2);
                    ruminant.Weight         = StartingWeight + StartingWeightSD * randStdNormal;
                    ruminant.PreviousWeight = ruminant.Weight;

                    if (this.Gender == Sex.Female)
                    {
                        RuminantFemale ruminantFemale = ruminantBase as RuminantFemale;
                        ruminantFemale.DryBreeder         = true;
                        ruminantFemale.WeightAtConception = this.StartingWeight;
                        ruminantFemale.NumberOfBirths     = 0;
                    }

                    Individuals.Add(ruminantBase as Ruminant);
                }
            }

            return(Individuals);
        }
Esempio n. 11
0
        private void OnWFAnimalManage(object sender, EventArgs e)
        {
            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd.Where(a => a.HerdName == HerdName).ToList();

            RuminantType breedParams;

            // get breedParams when no herd remaining
            if (herd.Count() == 0)
            {
                breedParams = Resources.GetResourceItem("Ruminants", HerdName) as RuminantType;
            }
            else
            {
                breedParams = herd.FirstOrDefault().BreedParams;
            }

            // can sell off males any month as per NABSA
            // if we don't need this monthly, then it goes into next if statement with herd declaration
            // NABSA MALES - weaners, 1-2, 2-3 and 3-4 yo, we check for any male weaned and not a breeding sire.
            // check for sell age/weight of young males
            // if SellYoungFemalesLikeMales then all apply to both sexes else only males.
            foreach (var ind in herd.Where(a => a.Weaned & (SellFemalesLikeMales ? true : (a.Gender == Sex.Male)) & (a.Age >= SellingAge ^ a.Weight >= SellingWeight)))
            {
                bool sell = true;
                if (ind.GetType() == typeof(RuminantMale))
                {
                    // don't sell breeding sires.
                    sell = !((ind as RuminantMale).BreedingSire);
                }
                if (sell)
                {
                    ind.SaleFlag = Common.HerdChangeReason.AgeWeightSale;
                }
            }

            // if management month
            if (Clock.Today.Month == ManagementMonth ^ MonthlyManagement)
            {
                // Perform weaning
                foreach (var ind in herd.Where(a => a.Weaned == false))
                {
                    if (ind.Age >= WeaningAge ^ ind.Weight >= WeaningWeight)
                    {
                        ind.Wean();
                    }
                }

                // check for maximum age (females and males have different cutoffs)
                foreach (var ind in herd.Where(a => a.Age >= ((a.Gender == Sex.Female) ? MaximumBreederAge : MaximumBullAge)))
                {
                    ind.SaleFlag = Common.HerdChangeReason.MaxAgeSale;
                }

                // MALES
                // check for breeder bulls after sale of old individuals and buy/sell
                int numberinherd = herd.Where(a => a.Gender == Sex.Male & a.SaleFlag == Common.HerdChangeReason.None).Cast <RuminantMale>().Where(a => a.BreedingSire).Count();

                if (numberinherd > MaximumSiresKept)
                {
                    // sell bulls
                    // What rule? oldest first as they may be lost soonest
                    int numberToRemove = MaximumSiresKept - numberinherd;
                    foreach (var male in herd.Where(a => a.Gender == Sex.Male).Cast <RuminantMale>().Where(a => a.BreedingSire).OrderByDescending(a => a.Age).Take(numberToRemove))
                    {
                        male.SaleFlag = Common.HerdChangeReason.ExcessBullSale;
                    }
                }
                else if (numberinherd < MaximumSiresKept)
                {
                    // remove young bulls from sale herd to replace breed bulls (not those sold because too old)
                    foreach (RuminantMale male in herd.Where(a => a.Gender == Sex.Male & a.SaleFlag == Common.HerdChangeReason.AgeWeightSale).OrderByDescending(a => a.Weight))
                    {
                        male.SaleFlag     = Common.HerdChangeReason.None;
                        male.BreedingSire = true;
                        numberinherd++;
                        if (numberinherd >= MaximumSiresKept)
                        {
                            break;
                        }
                    }

                    // if still insufficient buy bulls.
                    if (numberinherd < MaximumSiresKept)
                    {
                        int numberToBuy = Convert.ToInt32((MaximumSiresKept - numberinherd) * 0.05);

                        for (int i = 0; i < numberToBuy; i++)
                        {
                            RuminantMale newbull = new RuminantMale();
                            newbull.Age          = 48;
                            newbull.HerdName     = HerdName;
                            newbull.BreedingSire = true;
                            newbull.BreedParams  = breedParams;
                            newbull.Gender       = Sex.Male;
                            newbull.ID           = ruminantHerd.NextUniqueID;
                            newbull.Weight       = 450;
                            newbull.HighWeight   = newbull.Weight;
                            newbull.SaleFlag     = Common.HerdChangeReason.SirePurchase;

                            // add to purchase request list and await purchase in Buy/ Sell
                            ruminantHerd.PurchaseIndividuals.Add(newbull);
                        }
                    }
                }

                // FEMALES
                // check for maximum number of breeders remaining after sale and buy/sell
                numberinherd = herd.Where(a => a.Gender == Sex.Female & a.Age >= a.BreedParams.MinimumAge1stMating & a.SaleFlag == Common.HerdChangeReason.None).Count();

                if (numberinherd > MaximumBreedersKept)
                {
                    // sell breeders
                    // What rule? oldest first as they may be lost soonest
                    // should keep pregnant females... and young...
                    // this will currently remove pregnant females and females with suckling calf
                    int numberToRemove = MaximumBreedersKept - numberinherd;
                    foreach (var female in herd.Where(a => a.Gender == Sex.Female & a.Age >= a.BreedParams.MinimumAge1stMating).OrderByDescending(a => a.Age).Take(numberToRemove))
                    {
                        female.SaleFlag = Common.HerdChangeReason.ExcessBreederSale;
                    }
                }
                else
                {
                    // remove young females from sale herd to replace breeders (not those sold because too old)
                    foreach (RuminantFemale female in herd.Where(a => a.Gender == Sex.Female & a.SaleFlag == Common.HerdChangeReason.AgeWeightSale).OrderByDescending(a => a.Weight))
                    {
                        female.SaleFlag = Common.HerdChangeReason.None;
                        numberinherd++;
                        if (numberinherd >= MaximumBreedersKept)
                        {
                            break;
                        }
                    }

                    // if still insufficient buy breeders.
                    if (numberinherd < MaximumBreedersKept)
                    {
                        int    ageOfHeifer    = 12;
                        double weightOfHeifer = 260;

                        int numberToBuy = Convert.ToInt32((MaximumBreedersKept - numberinherd) * 0.05);

                        for (int i = 0; i < numberToBuy; i++)
                        {
                            RuminantFemale newheifer = new RuminantFemale();
                            newheifer.Age         = ageOfHeifer;
                            newheifer.HerdName    = HerdName;
                            newheifer.BreedParams = breedParams;
                            newheifer.Gender      = Sex.Female;
                            newheifer.ID          = ruminantHerd.NextUniqueID;
                            newheifer.Weight      = weightOfHeifer;
                            newheifer.HighWeight  = newheifer.Weight;
                            newheifer.SaleFlag    = Common.HerdChangeReason.HeiferPurchase;

                            // add to purchase request list and await purchase in Buy/ Sell
                            ruminantHerd.PurchaseIndividuals.Add(newheifer);
                        }
                    }
                }
            }
        }
Esempio n. 12
0
        private void OnWFAnimalDeath(object sender, EventArgs e)
        {
            // remove individuals that died
            // currently performed in the month after weight has been adjusted
            // and before breeding, trading, culling etc (See Clock event order)

            // Calculated by
            // critical weight &
            // juvenile (unweaned) death based on mothers weight &
            // adult weight adjusted base mortality.

            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd;

            // weight based mortality
            List <Ruminant> died = herd.Where(a => a.Weight < (a.HighWeight * (1.0 - a.BreedParams.ProportionOfMaxWeightToSurvive))).ToList();

            // set died flag
            died.Select(a => { a.SaleFlag = Common.HerdChangeReason.Died; return(a); }).ToList();
            ruminantHerd.RemoveRuminant(died);

            TMyRandom randomGenerator = new TMyRandom(10);

            foreach (var ind in ruminantHerd.Herd)
            {
                double mortalityRate = 0;
                if (!ind.Weaned)
                {
                    mortalityRate = 0;
                    if (ind.Mother.Weight < ind.BreedParams.CriticalCowWeight * ind.StandardReferenceWeight)
                    {
                        mortalityRate = ind.BreedParams.JuvenileMortalityMaximum;
                    }
                    else
                    {
                        mortalityRate = Math.Exp(-Math.Pow(ind.BreedParams.JuvenileMortalityCoefficient * (ind.Weight / ind.NormalisedAnimalWeight), ind.BreedParams.JuvenileMortalityExponent)) / 100;
                    }
                    mortalityRate += mortalityRate + ind.BreedParams.MortalityBase;
                    mortalityRate  = Math.Max(mortalityRate, ind.BreedParams.JuvenileMortalityMaximum);
                }
                else
                {
                    mortalityRate = 1 - (1 - ind.BreedParams.MortalityBase) * (1 - Math.Exp(Math.Pow(-(ind.BreedParams.MortalityCoefficient * (ind.Weight / ind.NormalisedAnimalWeight - ind.BreedParams.MortalityIntercept)), ind.BreedParams.MortalityExponent)));
                }
                if (randomGenerator.RandNo <= mortalityRate)
                {
                    ind.Died = true;
                }
            }

            died = herd.Where(a => a.Died).ToList();
            died.Select(a => { a.SaleFlag = Common.HerdChangeReason.Died; return(a); }).ToList();
            ruminantHerd.RemoveRuminant(died);

            //// mortality calculation (calculation actually calculates the survival probability)
            //for (int i = herd.Count; i >= 0; i--)
            //{
            //	double mortalityRate = 0;
            //	if (!herd[i].Weaned)
            //	{
            //		mortalityRate = 0;
            //		if (herd[i].Mother.Weight < herd[i].BreedParams.CriticalCowWeight * herd[i].StandardReferenceWeight)
            //		{
            //			mortalityRate = herd[i].BreedParams.JuvenileMortalityMaximum;
            //		}
            //		else
            //		{
            //			mortalityRate = Math.Exp(-Math.Pow(herd[i].BreedParams.JuvenileMortalityCoefficient * (herd[i].Weight / herd[i].NormalisedAnimalWeight), herd[i].BreedParams.JuvenileMortalityExponent)) / 100;
            //		}
            //		mortalityRate += mortalityRate + herd[i].BreedParams.MortalityBase;
            //		mortalityRate = Math.Max(mortalityRate, herd[i].BreedParams.JuvenileMortalityMaximum);
            //	}
            //	else
            //	{
            //		mortalityRate = 1 - (1 - herd[i].BreedParams.MortalityBase) * (1 - Math.Exp(Math.Pow(-(herd[i].BreedParams.MortalityCoefficient * (herd[i].Weight / herd[i].NormalisedAnimalWeight - herd[i].BreedParams.MortalityIntercept)), herd[i].BreedParams.MortalityExponent)));
            //	}
            //	if (randomGenerator.RandNo <= mortalityRate)
            //	{
            //		herd[i].Died = true;
            //	}
            //}
        }
Esempio n. 13
0
        private void OnWFAnimalWeightGain(object sender, EventArgs e)
        {
            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd;

            double totalMethane = 0;

            // grow all weaned individuals

            foreach (Ruminant ind in herd.Where(a => (a.Weaned == true)))
            {
                // calculate protein concentration

                // Calculate diet dry matter digestibilty from the %N of the current diet intake.
                // Reference: Ash and McIvor
                //ind.DietDryMatterDigestibility = 36.7 + 9.36 * ind.PercentNOfIntake / 62.5;
                // Now tracked via incoming food DMD values

                // TODO: NABSA restricts Diet_DMD to 75% before supplements. Why?
                // Our flow has already taken in supplements by this stage and cannot be distinguished
                // Maybe this limit should be placed on some feed to limit DMD to 75% for non supp feeds

                // TODO: Check equation. NABSA doesn't include the 0.9
                // Crude protein required generally 130g per kg of digestable feed.
                double crudeProteinRequired = ind.BreedParams.ProteinCoefficient * ind.DietDryMatterDigestibility / 100;

                // adjust for efficiency of use of protein, 90% degradable
                double crudeProteinSupply = (ind.PercentNOfIntake * 62.5) * 0.9;
                // This was proteinconcentration * 0.9

                // prevent future divide by zero issues.
                if (crudeProteinSupply == 0.0)
                {
                    crudeProteinSupply = 0.001;
                }

                double ratioSupplyRequired = Math.Min(0.3, Math.Max(1.3, crudeProteinSupply / crudeProteinRequired));

                // TODO: check if we still need to apply modification to only the non-supplemented component of intake

                ind.Intake *= ratioSupplyRequired;
                ind.Intake  = Math.Min(ind.Intake, ind.PotentialIntake * 1.2);

                // TODO: nabsa adjusts potential intake for digestability of fodder here.
                // I'm sure it can be done here, but prob as this is after the 1.2x cap has been performed.
                // calculate from the pools of fodder fed to this individual
                //if (0.8 - ind.BreedParams.IntakeTropicalQuality - dietDMD / 100 >= 0)
                //{
                //	ind.PotentialIntake *= ind.BreedParams.IntakeCoefficientQuality * (0.8 - ind.BreedParams.IntakeTropicalQuality - dietDMD / 100);
                //}

                // calculate energy
                // includes mortality and growth
                double methane = 0;

                CalculateEnergy(ind, out methane);

                // ? call methane produced event
                // or sum and produce one event for breed at end of loop
                totalMethane += methane;

                // calculate manure
                // ? call manure produce event
                // or sum and produce one event for breed at end of loop

                // grow wool and cashmere
                ind.Wool     += ind.BreedParams.WoolCoefficient * ind.Intake;
                ind.Cashmere += ind.BreedParams.CashmereCoefficient * ind.Intake;
            }
        }
Esempio n. 14
0
        private void OnStartOfSimulation(object sender, EventArgs e)
        {
            // This needs to happen after all herd creation has been performed
            // Therefore we use StartOfSimulation event

            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd.Where(a => a.HerdName == HerdName).ToList();

            // get list of females of breeding age and condition
            List <RuminantFemale> breedFemales = herd.Where(a => a.Gender == Sex.Female & a.Age >= a.BreedParams.MinimumAge1stMating + 12 & a.Weight >= (a.BreedParams.MinimumSize1stMating * a.StandardReferenceWeight) & a.Weight >= (a.BreedParams.CriticalCowWeight * a.StandardReferenceWeight)).OrderByDescending(a => a.Age).ToList().Cast <RuminantFemale>().ToList();

            // get list of all sucking individuals
            List <Ruminant> sucklingList = herd.Where(a => a.Weaned == false).ToList();

            if (breedFemales.Count() == 0)
            {
                if (sucklingList.Count > 0)
                {
                    Summary.WriteWarning(this, String.Format("No breeding females to assign sucklings for herd ({0})", HerdName));
                }
                return;
            }

            // gestation interval at smallest size generalised curve
            double minAnimalWeight = breedFemales[0].StandardReferenceWeight - ((1 - breedFemales[0].BreedParams.SRWBirth) * breedFemales[0].StandardReferenceWeight) * Math.Exp(-(breedFemales[0].BreedParams.AgeGrowthRateCoefficient * (breedFemales[0].BreedParams.MinimumAge1stMating * 30.4)) / (Math.Pow(breedFemales[0].StandardReferenceWeight, breedFemales[0].BreedParams.SRWGrowthScalar)));
            double IPIminsize      = Math.Pow(breedFemales[0].BreedParams.InterParturitionIntervalIntercept * (minAnimalWeight / breedFemales[0].StandardReferenceWeight), breedFemales[0].BreedParams.InterParturitionIntervalCoefficient) * 30.64;

            // restrict minimum period between births
            IPIminsize = Math.Max(IPIminsize, breedFemales[0].BreedParams.GestationLength + 61);

            // assign calves to cows
            foreach (var suckling in sucklingList)
            {
                if (breedFemales.Count > 0)
                {
                    breedFemales[0].DryBreeder = false;

                    //Initialise female milk production in at birth so ready for sucklings to consume
                    double milkTime       = 15;               // equivalent to mid month production
                    double milkProduction = breedFemales[0].BreedParams.MilkPeakYield * breedFemales[0].Weight / breedFemales[0].NormalisedAnimalWeight * (Math.Pow(((milkTime + breedFemales[0].BreedParams.MilkOffsetDay) / breedFemales[0].BreedParams.MilkPeakDay), breedFemales[0].BreedParams.MilkCurveSuckling)) * Math.Exp(breedFemales[0].BreedParams.MilkCurveSuckling * (1 - (milkTime + breedFemales[0].BreedParams.MilkOffsetDay) / breedFemales[0].BreedParams.MilkPeakDay));
                    breedFemales[0].MilkProduction = Math.Max(milkProduction, 0.0);
                    breedFemales[0].MilkAmount     = milkProduction * 30.4;

                    // generalised curve
                    double IPIcurrent = Math.Pow(breedFemales[0].BreedParams.InterParturitionIntervalIntercept * (breedFemales[0].Weight / breedFemales[0].StandardReferenceWeight), breedFemales[0].BreedParams.InterParturitionIntervalCoefficient) * 30.64;
                    // restrict minimum period between births
                    IPIcurrent = Math.Max(IPIcurrent, breedFemales[0].BreedParams.GestationLength + 61);

                    breedFemales[0].NumberOfBirths = Convert.ToInt32((breedFemales[0].Age - suckling.Age - breedFemales[0].BreedParams.GestationLength - breedFemales[0].BreedParams.MinimumAge1stMating) / ((IPIcurrent + IPIminsize) / 2));

                    //breedFemales[0].Parity = breedFemales[0].Age - suckling.Age - 9;
                    // I removed the -9 as this would make it conception month not birth month
                    breedFemales[0].AgeAtLastBirth      = breedFemales[0].Age - suckling.Age;
                    breedFemales[0].AgeAtLastConception = breedFemales[0].AgeAtLastBirth - breedFemales[0].BreedParams.GestationLength;

                    // suckling mother set
                    suckling.Mother = breedFemales[0];

                    // check if a twin and if so apply next individual to same mother.
                    // otherwise remove this mother from the list
                    if (randomGenerator.RandNo >= breedFemales[0].BreedParams.TwinRate)
                    {
                        breedFemales.RemoveAt(0);
                    }
                }
                else
                {
                    Summary.WriteWarning(this, String.Format("Insufficient breeding females to assign sucklings for herd ({0})", HerdName));
                    return;
                }
            }

            // assing values for the remaining females who haven't just bred.
            foreach (var female in breedFemales)
            {
                female.DryBreeder = true;
                // generalised curve
                double IPIcurrent = Math.Pow(breedFemales[0].BreedParams.InterParturitionIntervalIntercept * (breedFemales[0].Weight / breedFemales[0].StandardReferenceWeight), breedFemales[0].BreedParams.InterParturitionIntervalCoefficient) * 30.64;
                // restrict minimum period between births
                IPIcurrent = Math.Max(IPIcurrent, breedFemales[0].BreedParams.GestationLength + 61);
                breedFemales[0].NumberOfBirths = Convert.ToInt32((breedFemales[0].Age - breedFemales[0].BreedParams.MinimumAge1stMating) / ((IPIcurrent + IPIminsize) / 2)) - 1;
                female.AgeAtLastBirth          = breedFemales[0].Age - 12;
            }
        }
Esempio n. 15
0
        private void OnWFAnimalBreeding(object sender, EventArgs e)
        {
            RuminantHerd    ruminantHerd = Resources.RuminantHerd();
            List <Ruminant> herd         = ruminantHerd.Herd.Where(a => a.BreedParams.Name == HerdName).ToList();

            // get list of all individuals of breeding age and condition
            // grouped by location
            var breeders = from ind in herd
                           where
                           (ind.Gender == Sex.Male & ind.Age >= ind.BreedParams.MinimumAge1stMating) ^
                           (ind.Gender == Sex.Female &
                            ind.Age >= ind.BreedParams.MinimumAge1stMating &
                            ind.Weight >= (ind.BreedParams.MinimumSize1stMating * ind.StandardReferenceWeight)
                           )
                           group ind by ind.Location into grp
                           select grp;

            // for each location where parts of this herd are located
            foreach (var location in breeders)
            {
                // check for births of all pregnant females.
                foreach (RuminantFemale female in location.Where(a => a.Gender == Sex.Female).Cast <RuminantFemale>().ToList())
                {
                    if (female.BirthDue)
                    {
                        int numberOfNewborn = (female.CarryingTwins) ? 2 : 1;
                        for (int i = 0; i < numberOfNewborn; i++)
                        {
                            // Determine if the offspring died during pregancy from conception to after birth
                            // This is currently only performed at time of birth rather than monthly during pregnancy
                            // and so does not reflect changes in female intake etc after dead of foetus.

                            // this now occurs monthly at the ned of this breeding method.
                            //if (randomGenerator.RandNo > female.BreedParams.PrenatalMortality)
                            //{
                            object newCalf = null;
                            bool   isMale  = (randomGenerator.RandNo > 0.5);
                            if (isMale)
                            {
                                newCalf = new RuminantMale();
                            }
                            else
                            {
                                newCalf = new RuminantFemale();
                            }
                            Ruminant newCalfRuminant = newCalf as Ruminant;
                            newCalfRuminant.Age         = 0;
                            newCalfRuminant.HerdName    = female.HerdName;
                            newCalfRuminant.BreedParams = female.BreedParams;
                            newCalfRuminant.Gender      = (isMale) ? Sex.Male : Sex.Female;
                            newCalfRuminant.ID          = ruminantHerd.NextUniqueID;
                            newCalfRuminant.Location    = female.Location;
                            newCalfRuminant.Mother      = female;
//							newCalfRuminant.Number = 1;
                            newCalfRuminant.SetUnweaned();
                            // calf weight from  Freer
                            newCalfRuminant.Weight     = female.BreedParams.SRWBirth * female.StandardReferenceWeight * (1 - 0.33 * (1 - female.Weight / female.StandardReferenceWeight));
                            newCalfRuminant.HighWeight = newCalfRuminant.Weight;
                            newCalfRuminant.SaleFlag   = Common.HerdChangeReason.Born;
                            ruminantHerd.AddRuminant(newCalfRuminant);

                            // add to sucklings
                            female.SucklingOffspring.Add(newCalfRuminant);

                            //}
                        }
                        female.UpdateBirthDetails();
                    }
                }

                // Conception
                // check if males and females of breeding condition are together
                if (location.GroupBy(a => a.Gender).Count() == 2)
                {
                    // servicing rate
                    int    maleCount       = location.Where(a => a.Gender == Sex.Male).Count();
                    int    femaleCount     = location.Where(a => a.Gender == Sex.Female).Count();
                    double matingsPossible = maleCount * location.FirstOrDefault().BreedParams.MaximumMaleMatingsPerDay * 30;
                    double maleLimiter     = Math.Max(1.0, matingsPossible / femaleCount);

                    foreach (RuminantFemale female in location.Where(a => a.Gender == Sex.Female).Cast <RuminantFemale>().ToList())
                    {
                        //TODO: ensure enough time since last calf
                        if (!female.IsPregnant & !female.IsLactating)
                        {
                            // calculate conception
                            double conceptionRate = ConceptionRate(female) * maleLimiter;
                            if (randomGenerator.RandNo <= conceptionRate)
                            {
                                female.UpdateConceptionDetails(randomGenerator.RandNo > female.BreedParams.TwinRate, conceptionRate);
                            }
                        }
                    }
                }

                // determine all foetus and newborn mortality.
                foreach (RuminantFemale female in location.Where(a => a.Gender == Sex.Female).Cast <RuminantFemale>().ToList())
                {
                    if (female.IsPregnant)
                    {
                        // calculate foetus and newborn mortality
                        // total mortality / gestation months to get monthly mortality

                        // TODO: check if need to be done before births to get last month mortality
                        if (randomGenerator.RandNo > female.BreedParams.PrenatalMortality / female.BreedParams.GestationLength)
                        {
                            female.OneOffspringDies();
                        }
                    }
                }
            }
        }
Esempio n. 16
0
 private void OnWFAnimalManage(object sender, EventArgs e)
 {
     RuminantHerd    ruminantHerd = Resources.RuminantHerd();
     List <Ruminant> herd         = ruminantHerd.Herd.Where(a => a.HerdName == HerdName).ToList();
 }