InraPorc

unit UCalcSimulP;

interface

uses

  UVariables;

 // Simul = N? de la simulation (-1 pour profil)

 // Profil, SeqAli, Ration = N? d'enregistrement pour comparaison

 // Variable = N? de la variable ? moduler

 // Variation = Coefficient de variation

 // Restrict = Coefficient de restriction

 // PResSimulP = Tableau de r?sultats

procedure CalcSimulP(Simul, Profil, SeqAli, Ration, Variable: integer;

  Variation: double; PResSimulP: PTabResSimulP; AALimit: Boolean = True);

implementation

uses

  Math, UFindRec, UCalcul;

procedure CalcSimulP(Simul, Profil, SeqAli, Ration, Variable: integer;

  Variation: double; PResSimulP: PTabResSimulP; AALimit: Boolean = True);

const

  Standing = 4;

  PVmr1 = 19.999;

  mrPV1 = 8.4 * GEProtJaap;

  mrPV2 = 0;

var

  i, j: integer;

  FinSimul, ErrSimul, ok: boolean;

  NumRuleSeqAli, NumRuleRation, RuleSeqAliInit, RuleRationInit, Unite: integer;

  Age, Ecart, AgeInit, AgeFin, ModeFinSim, Duree: integer;

  PDMoy, BGompertz, Entretien, PVmr2, ProtInit, ProtFin, PVFin: double;

  PV, p, PD, EnergyPD, l, LD, EnergyLD, PVVafter, PVafter, GMQ, PVV: double;

  PctAli1, PctAli2, Cumul, Init, QuantiteAL, Quantite: double;

  IngereAL, Ingere, IngereSec, IngSec1, IngSec2, Gaspillage: double;

  DEcrois, MEcrois, NEcrois: double;

  PDFirstLimit, FHP60, NEmAL, NEm, NEintakeAL: double;

  PDAL, px1AL, py1AL, mr, F, a, b, PDmaxE, NEintake, px1, py1, PfreeNE: double;

  ExcessProt, ObligUrinELoss, UrinEnergy, MEexcessProt, NEexcessProt: double;

  PDfreeNEintake, NEintakeSim, MEintake, PDfreeNEPD, PDfreeNEreq: double;

  TabAAdig, TabAAm, TabAAfG, TabPDAA: array[0..12] of double;

  TabDEIntake, TabProtFreeNE, TabProtFreeME: array[1..6] of double;

  RecCC1, RecCC2: CompositionChimique;

  TabAAtotal1, TabAAtotal2, TabCUDAA1, TabCUDAA2: array[0..12] of double;

  Gompertz, Pmat: Extended;

begin

  FinSimul := False;

  ErrSimul := False;

  // Initialisation du tableau de r?sultat

  for i := 1 to NB_COL_PORC do

    for j := 1 to MAX_LIG_PORC do

      PResSimulP.TabResult[i, j] := 0;

  // Initialisation de la simulation

  PResSimulP.NbJSim := 0;

  NumRuleSeqAli  := 1;

  RuleSeqAliInit := 1;

  NumRuleRation  := 1;

  RuleRationInit := 1;

  if Simul = -1 then // Profil

  begin

    // Initialisation du profil animal

    PProfilP := ListProfilP[FindIdxProfilP(FindNomProfilP(Profil))];

    // Initialisation de la s?quence alimentaire

    //    PSeqAliP := ListSeqAliP[FindIdxSeqAliP(FindNomSeqAliP(PProfilP.SeqAli))];

    PSeqAliP := ListSeqAliP[FindIdxSeqAliP(FindNomSeqAliP(SeqAli))];

    // Initialisation du plan de rationnement

    //    if PProfilP.Ration <> -1

    //    then

    //      PRationP := ListRationP[FindIdxRationP(FindNomRationP(PProfilP.Ration))];

    if Ration <> -1 then // plan de rationnement de la simulation

      PRationP := ListRationP[FindIdxRationP(FindNomRationP(Ration))];

    // D?but et fin de simulation

    Age := PProfilP.AgeInit;

    PV := PProfilP.PVInit;

    p  := PProfilP.ProtInit;

    l  := PProfilP.LipInit;

    ModeFinSim := PProfilP.ModeFin;

    Duree := PProfilP.Duree;

    PVFin := PProfilP.PVFin;

  end

  else // Simulation

  begin

    // Initialisation des param?tres de simulation

    PSimulP := ListSimulP[FindIdxSimulP(FindNomSimulP(Simul))];

    // Initialisation du profil animal

    if Profil = -1 then // Profil de la simulation

      PProfilP := ListProfilP[FindIdxProfilP(FindNomProfilP(PSimulP.Profil))]

    else

      PProfilP := ListProfilP[FindIdxProfilP(FindNomProfilP(Profil))];

    // Initialisation de la s?quence alimentaire

    if SeqAli = -1 then // S?quence alimentaire de la simulation

      PSeqAliP := ListSeqAliP[FindIdxSeqAliP(FindNomSeqAliP(PSimulP.SeqAli))]

    else

      PSeqAliP := ListSeqAliP[FindIdxSeqAliP(FindNomSeqAliP(SeqAli))];

    // Initialisation du plan de rationnement

    if Ration = -1 then // plan de rationnement de la simulation

      PRationP := ListRationP[FindIdxRationP(FindNomRationP(PSimulP.Ration))]

    else

      PRationP := ListRationP[FindIdxRationP(FindNomRationP(Ration))];

    // D?but et fin de simulation

    if PSimulP.AgeInitProfil then // Profil

      Age := PProfilP.AgeInit

    else // Simulation

      Age := PSimulP.AgeInit;

    if PSimulP.PVInitProfil then // Profil

      PV := PProfilP.PVInit

    else // Simulation

      PV := PSimulP.PVInit;

    if PSimulP.ProtLipInitProfil then // Profil

      if PSimulP.PVInitProfil then // Valeurs stock?es

      begin

        p := PProfilP.ProtInit;

        l := PProfilP.LipInit;

      end

      else // Valeurs calcul?es

      begin

        p := CalcProt(PV);

        l := CalcLipProt(PV, p);

      end

    else // Simulation

    begin

      p := PSimulP.ProtInit;

      l := PSimulP.LipInit;

    end;

    if PSimulP.FinProfil then // Profil

    begin

      ModeFinSim := PProfilP.ModeFin;

      Duree := PProfilP.Duree;

      PVFin := PProfilP.PVFin;

    end

    else // Simulation

    begin

      ModeFinSim := PSimulP.ModeFin;

      Duree := PSimulP.Duree;

      PVFin := PSimulP.PVFin;

    end;

  end;

  AgeInit := Age;

  ProtInit := p;

  PDMoy := PProfilP.PDMoy;

  BGompertz := PProfilP.BGompertz;

  Entretien := PProfilP.Entretien;

  PVmr2 := PProfilP.PVmr2;

  // Sensibilit? (animal)

  case Variable of

    0: // PD moyen

      PDMoy := PDMoy * Variation;

    1: // Pr?cocit?

      BGompertz := BGompertz * Variation;

    2: // Entretien

      Entretien := Entretien * Variation;

    3: // PV PDMax

      PVmr2 := PVmr2 * Variation;

    4: // Etat final

    begin

      Duree := Round(Duree * Variation);

      PVFin := PVFin * Variation;

    end;

  end;

  // Poids de prot?ines ? la maturit?

  if PProfilP.ModeFin = 0 then // Dur?e

  begin

    AgeFin  := PProfilP.AgeInit + PProfilP.Duree;

    ProtFin := PProfilP.Duree * (PDMoy / 1000) + PProfilP.ProtInit;

  end

  else // Poids

  begin

    AgeFin  := Round((CalcProt(PProfilP.PVFin) - PProfilP.ProtInit) / (PDMoy / 1000)) + PProfilP.AgeInit;

    ProtFin := (AgeFin - PProfilP.AgeInit) * (PDMoy / 1000) + PProfilP.ProtInit;

  end;

  Gompertz := Exp(-BGompertz * (AgeFin - PProfilP.AgeInit));

  Pmat := ProtFin * Power(ProtFin / PProfilP.ProtInit, Gompertz / (1 - Gompertz));

  repeat

    Inc(PResSimulP.NbJSim);

    PVV := CalcPVV(PV);

    PResSimulP.TabResult[1, PResSimulP.NbJSim] := Age;

    PResSimulP.TabResult[2, PResSimulP.NbJSim] := PV;

    PResSimulP.TabResult[48, PResSimulP.NbJSim] := PVV;

    PResSimulP.TabResult[49, PResSimulP.NbJSim] := p;

    PResSimulP.TabResult[50, PResSimulP.NbJSim] := l;

    PResSimulP.TabResult[70, PResSimulP.NbJSim] := Standing * Entretien;

    PResSimulP.TabResult[85, PResSimulP.NbJSim] := Pmat;

    PResSimulP.TabResult[107, PResSimulP.NbJSim] := AgeFin;

    PResSimulP.TabResult[108, PResSimulP.NbJSim] := ProtFin;

    // Muscle

    //    PResSimulP.TabResult[107, PResSimulP.NbJSim] := CalcMuscle(PVV, l);

    // TVM

    //    PResSimulP.TabResult[108, PResSimulP.NbJSim] := CalcTVM(PVV, l);

    /////////////////////////

    // Apports journaliers //

    /////////////////////////

    // Aliment(s) distribu?(s)

    repeat

      ok := True;

      with PSeqAliP.Rule[NumRuleSeqAli] do

        case ModeFin of

          0: // Dur?e

            if PResSimulP.NbJSim - RuleSeqAliInit >= ValFin then

              ok := False;

          1: // Age

            if Age > ValFin then

              ok := False;

          2: // Poids vif

            if PV >= ValFin then

              ok := False;

          3: // Cumul aliment

          begin

            Cumul := 0;

            for i := RuleSeqAliInit to PResSimulP.NbJSim do

              Cumul := Cumul + PResSimulP.TabResult[113, i];

            if Cumul >= ValFin then

              ok := False;

          end;

        end;

      if not ok then // Changement de r?gle

      begin

        Inc(NumRuleSeqAli);

        RuleSeqAliInit := PResSimulP.NbJSim;

      end;

    until ok;

    with PSeqAliP.Rule[NumRuleSeqAli] do

    begin

      PResSimulP.TabResult[3, PResSimulP.NbJSim] := NumRuleSeqAli;

      PResSimulP.TabResult[4, PResSimulP.NbJSim] := ModeFin;

      PResSimulP.TabResult[7, PResSimulP.NbJSim] := NumAli1;

      PResSimulP.TabResult[8, PResSimulP.NbJSim] := NumAli2;

      // Composition aliment 1

      if NumAli1 = -1 then

      begin

        RecCC1 := CCVide;

        for i := 0 to 12 do

          TabAAtotal1[i] := 0;

        for i := 0 to 12 do

          TabCUDAA1[i] := 0;

      end

      else

      begin

        PAliment := ListAliment[FindIdxAliment(FindNomAliment(NumAli1))];

        RecCC1 := PAliment.CC;

        for i := 0 to 12 do

          TabAAtotal1[i] := PAliment.AAtotal[i];

        for i := 0 to 12 do

          TabCUDAA1[i] := PAliment.CUDAA[i];

      end;

      // Composition aliment 2

      if NumAli2 = -1 then

      begin

        RecCC2 := CCVide;

        for i := 0 to 12 do

          TabAAtotal2[i] := 0;

        for i := 0 to 12 do

          TabCUDAA2[i] := 0;

      end

      else

      begin

        PAliment := ListAliment[FindIdxAliment(FindNomAliment(NumAli2))];

        RecCC2 := PAliment.CC;

        for i := 0 to 12 do

          TabAAtotal2[i] := PAliment.AAtotal[i];

        for i := 0 to 12 do

          TabCUDAA2[i] := PAliment.CUDAA[i];

      end;

      // Calcul des % aliments

      if PctAli1Init = PctAli1Fin then

        PctAli1 := PctAli1Init

      else // Transition

      begin

        Ecart := PctAli1Fin - PctAli1Init;

        case ModeFin of

          -1: // Fin de simulation

            case ModeFinSim of

              0: // Dur?e

                PctAli1 := PctAli1Init + (PResSimulP.NbJSim - RuleSeqAliInit) * Ecart / (Duree - 1);

              1: // Poids vif

              begin

                Init := PResSimulP.TabResult[2, RuleSeqAliInit];

                PctAli1 := PctAli1Init + (PV - Init) * Ecart / (PVFin - Init);

              end;

              else

                PctAli1 := PctAli1Init;

            end;

          0: // Dur?e

            PctAli1 := PctAli1Init + (PResSimulP.NbJSim - RuleSeqAliInit) * Ecart / (ValFin - 1);

          1: // Age

          begin

            Init := PResSimulP.TabResult[1, RuleSeqAliInit];

            PctAli1 := PctAli1Init + (Age - Init) * Ecart / (ValFin - Init);

          end;

          2: // Poids vif

          begin

            Init := PResSimulP.TabResult[2, RuleSeqAliInit];

            PctAli1 := PctAli1Init + (PV - Init) * Ecart / (ValFin - Init);

          end;

          else

            PctAli1 := PctAli1Init;

        end;

        if (PctAli1 > 100) then

          PctAli1 := 100;

        if (PctAli1 < 0) then

          PctAli1 := 0;

      end;

    end;

    PResSimulP.TabResult[9, PResSimulP.NbJSim] := PctAli1;

    PctAli2 := 100 - PctAli1;

    PResSimulP.TabResult[10, PResSimulP.NbJSim] := PctAli2;

    // Ing?r? AdLib

    with PProfilP^ do

    begin

      // Calcul des quantit?s

      {

      case Equation of

        0 : // a+b*PV

          QuantiteAL := a + b * PV ;

        1 : // a*PV^b

          QuantiteAL := a * Power (PV, b) ;

        2 : // a*(1-exp(-b*PV))

          QuantiteAL := a * (1 - Exp (-b * PV)) ;

        else

          QuantiteAL := 0 ;

      end ;

      }

      QuantiteAL := CalcIngere(Equation, Unite, a, b, PV);

      // Convertion de ED, EM, EN en quantit? si besoin

      case Unite of

        1: // ED (MJ/j)

          IngereAL := QuantiteAL / (PctAli1 / 100 *

            RecCC1.ED_C * RecCC1.MS / 1000 + PctAli2 / 100 *

            RecCC2.ED_C * RecCC2.MS / 1000);

        2: // EM (MJ/j)

          IngereAL := QuantiteAL / (PctAli1 / 100 *

            RecCC1.EM_C * RecCC1.MS / 1000 + PctAli2 / 100 *

            RecCC2.EM_C * RecCC2.MS / 1000);

        3: // EN (MJ/j)

          IngereAL := QuantiteAL / (PctAli1 / 100 *

            RecCC1.EN_C * RecCC1.MS / 1000 + PctAli2 / 100 *

            RecCC2.EN_C * RecCC2.MS / 1000);

        4: // MS (kg/j)

          IngereAL := QuantiteAL / (PctAli1 / 100 *

            RecCC1.MS / 1000 + PctAli2 / 100 * RecCC2.MS / 1000);

        else // Quantit? (kg/j)

          IngereAL := QuantiteAL;

      end;

    end;

    PResSimulP.TabResult[78, PResSimulP.NbJSim] := IngereAL;

    // Quantit?(s) distribu?e(s)

    if (Simul = -1) and (Ration = -1) then // Consommation AdLib

      Ingere := IngereAL

    else // Plan de rationnement

    begin

      repeat

        ok := True;

        with PRationP.Rule[NumRuleRation] do

          case ModeFin of

            0: // Dur?e

              if PResSimulP.NbJSim - RuleRationInit >= ValFin then

                ok := False;

            1: // Age

              if Age > ValFin then

                ok := False;

            2: // Poids vif

              if PV >= ValFin then

                ok := False;

            3: // Cumul aliment

            begin

              Cumul := 0;

              for i := RuleRationInit to PResSimulP.NbJSim do

                Cumul := Cumul + PResSimulP.TabResult[113, i];

              if Cumul >= ValFin then

                ok := False;

            end;

            4..8: // Consommation

              if PResSimulP.NbJSim > 1 then

              begin

                i := PResSimulP.NbJSim - 1;

                case ModeFin of

                  4: // Consommation (aliment)

                    if PResSimulP.TabResult[113, i] >= ValFin then

                      ok := False;

                  5: // Consommation (MS)

                    if PResSimulP.TabResult[106, i] * PResSimulP.TabResult[113, i] >=

                      ValFin then

                      ok := False;

                  6: // Consommation (ED)

                    if PResSimulP.TabResult[109, i] * PResSimulP.TabResult[113, i] >=

                      ValFin then

                      ok := False;

                  7: // Consommation (EM)

                    if PResSimulP.TabResult[89, i] * PResSimulP.TabResult[113, i] >=

                      ValFin then

                      ok := False;

                  8: // Consommation (EN)

                    if PResSimulP.TabResult[90, i] * PResSimulP.TabResult[113, i] >=

                      ValFin then

                      ok := False;

                end;

              end;

          end;

        if not ok then // Changement de r?gle

        begin

          Inc(NumRuleRation);

          RuleRationInit := PResSimulP.NbJSim;

        end;

      until ok;

      with PRationP.Rule[NumRuleRation] do

      begin

        PResSimulP.TabResult[5, PResSimulP.NbJSim] := NumRuleRation;

        PResSimulP.TabResult[6, PResSimulP.NbJSim] := ModeFin;

        // Calcul des quantit?s

        case RuleType of

          0: // % Ad libitum

            Quantite := QuantiteAL * Percent;

          1: // Constant

            Quantite := Quantity;

          2: // f(dur?e)

            case EqDuree of

              0: // a+b*jour

              begin

                Init := PResSimulP.TabResult[1, RuleRationInit];

                Quantite := aDuree + bDuree * (Age - Init);

              end;

              1: // a+b*semaine

              begin

                Init := PResSimulP.TabResult[1, RuleRationInit];

                Quantite := aDuree + bDuree * Trunc((Age - Init) / 7);

              end;

              else

                Quantite := 0;

            end;

          3: // f(poids vif)

            {

            case EqPV of

              0: // a+b*PV

                Quantite := aPV + bPV * PV;

              1: // a*PV^b

                Quantite := aPV * Power(PV, bPV);

              2: // a*(1-exp(-b*PV))

                Quantite := aPV * (1 - Exp(-bPV * PV));

              else

                Quantite := 0;

            end;

            }

            Quantite := CalcIngere(EqPV, Unite, aPV, bPV, PV);

          else

            Quantite := 0;

        end;

      end;

      // Convertion de ED, EM, EN en quantit? si besoin

      if PRationP.Rule[NumRuleRation].RuleType = 0 then

        // % AdLib : Unite est d?finie au niveau du profil

        Unite := PProfilP.Unite

      else

        Unite := PRationP.Rule[NumRuleRation].Unite;

      case Unite of

        1: // ED (MJ/j)

          Ingere := Quantite / (PctAli1 / 100 * RecCC1.ED_C *

            RecCC1.MS / 1000 + PctAli2 / 100 * RecCC2.ED_C * RecCC2.MS / 1000);

        2: // EM (MJ/j)

          Ingere := Quantite / (PctAli1 / 100 * RecCC1.EM_C *

            RecCC1.MS / 1000 + PctAli2 / 100 * RecCC2.EM_C * RecCC2.MS / 1000);

        3: // EN (MJ/j)

          Ingere := Quantite / (PctAli1 / 100 * RecCC1.EN_C *

            RecCC1.MS / 1000 + PctAli2 / 100 * RecCC2.EN_C * RecCC2.MS / 1000);

        4: // MS (kg/j)

          Ingere := Quantite / (PctAli1 / 100 * RecCC1.MS /

            1000 + PctAli2 / 100 * RecCC2.MS / 1000);

        else // Quantit? (kg/j)

          Ingere := Quantite;

      end;

    end;

    // Gaspillage

    if (Simul = -1) and (Ration = -1) then // Ad libitum : pas de gaspillage

      Gaspillage := 0

    else

      Gaspillage := PRationP.Rule[NumRuleRation].Gaspillage;

    // Sensibilit? (aliment)

    case Variable of

      5: // Quantit? d'aliment

        Ingere := Ingere * Variation;

      6: // Gaspillage

        Gaspillage := Max(Gaspillage + Variation, 0);

      7..18: // Acides amin?s

      begin

        TabAAtotal1[Variable - 6] := TabAAtotal1[Variable - 6] * Variation;

        TabAAtotal2[Variable - 6] := TabAAtotal2[Variable - 6] * Variation;

        if (Variable = 9) or (Variable = 13) then // met+cys ou phe+tyr

        begin

          TabAAtotal1[Variable - 7] := TabAAtotal1[Variable - 7] * Variation;

          TabAAtotal2[Variable - 7] := TabAAtotal2[Variable - 7] * Variation;

        end;

      end;

    end;

    PResSimulP.TabResult[11, PResSimulP.NbJSim] := Ingere;

    PResSimulP.TabResult[112, PResSimulP.NbJSim] := Gaspillage;

    PResSimulP.TabResult[113, PResSimulP.NbJSim] := Ingere / (1 - Gaspillage);

    // Calcul des apports journaliers

    IngSec1 := Ingere * PctAli1 / 100 * RecCC1.MS / 1000;

    IngSec2 := Ingere * PctAli2 / 100 * RecCC2.MS / 1000;

    IngereSec := IngSec1 + IngSec2;

    if Ingere <> 0 then

      PResSimulP.TabResult[106, PResSimulP.NbJSim] := IngereSec / Ingere;

    // Energie brute ing?r?e

    PResSimulP.TabResult[12, PResSimulP.NbJSim] :=

      IngSec1 * RecCC1.EB + IngSec2 * RecCC2.EB;

    // Composants digestibles ing?r?s

    TabDEIntake[1] := IngSec1 * RecCC1.MAT * RecCC1.dMAT_C / 100 +

      IngSec2 * RecCC2.MAT * RecCC2.dMAT_C / 100;

    TabDEIntake[2] := IngSec1 * RecCC1.Lip * RecCC1.dLip_C / 100 +

      IngSec2 * RecCC2.Lip * RecCC2.dLip_C / 100;

    TabDEIntake[3] := IngSec1 * RecCC1.Amidon + IngSec2 * RecCC2.Amidon;

    TabDEIntake[4] := IngSec1 * RecCC1.Sucres + IngSec2 * RecCC2.Sucres;

    TabDEIntake[5] := IngSec1 * RecCC1.CB * RecCC1.dCB_C / 100 +

      IngSec2 * RecCC2.CB * RecCC2.dCB_C / 100;

    TabDEIntake[6] := IngSec1 * RecCC1.Residu * RecCC1.dResidu_C /

      100 + IngSec2 * RecCC2.Residu * RecCC2.dResidu_C / 100;

    for i := 1 to 6 do

      PResSimulP.TabResult[12 + i, PResSimulP.NbJSim] := TabDEIntake[i];

    // Acides amin?s totaux ing?r?s

    for i := 0 to 12 do

      PResSimulP.TabResult[93 + i, PResSimulP.NbJSim] :=

        IngSec1 * TabAAtotal1[i] + IngSec2 * TabAAtotal2[i];

    // Acides amin?s digestibles ing?r?s

    for i := 0 to 12 do

      TabAAdig[i] := IngSec1 * TabAAtotal1[i] * TabCUDAA1[i] / 100 +

        IngSec2 * TabAAtotal2[i] * TabCUDAA2[i] / 100;

    for i := 0 to 12 do

      PResSimulP.TabResult[19 + i, PResSimulP.NbJSim] := TabAAdig[i];

    ////////////////

    // Simulation //

    ////////////////

    // Calcul de l'ED croissance

    if Ingere = 0 then

      DEcrois := 0

    else

      DEcrois := (IngSec1 * RecCC1.ED_C + IngSec2 * RecCC2.ED_C) / Ingere;

    PResSimulP.TabResult[109, PResSimulP.NbJSim] := DEcrois;

    // Calcul de l'EM croissance

    if Ingere = 0 then

      MEcrois := 0

    else

      MEcrois := (IngSec1 * RecCC1.EM_C + IngSec2 * RecCC2.EM_C) / Ingere;

    PResSimulP.TabResult[89, PResSimulP.NbJSim] := MEcrois;

    // Calcul de l'EN croissance

    if Ingere = 0 then

      NEcrois := 0

    else

      NEcrois := (IngSec1 * RecCC1.EN_C + IngSec2 * RecCC2.EN_C) / Ingere;

    PResSimulP.TabResult[90, PResSimulP.NbJSim] := NEcrois;

    // D?pot de prot?ines et d'acides amin?s

    for i := 0 to 12 do

    begin

      TabAAm[i]  := AAm75[i] * Power(PV, 0.75) + IngereSec * AAendogene[i];

      TabAAfG[i] := (TabAAdig[i] - TabAAm[i]) * kAA[i];

      TabPDAA[i] := TabAAfG[i] / AAbody[i];

      PResSimulP.TabResult[32 + i, PResSimulP.NbJSim] := TabPDAA[i];

    end;

    // met+cys

    PResSimulP.TabResult[45, PResSimulP.NbJSim] :=

      (TabAAfG[2] + TabAAfG[3]) / (AAbody[2] + AAbody[3]);

    // phe+tyr

    PResSimulP.TabResult[46, PResSimulP.NbJSim] :=

      (TabAAfG[6] + TabAAfG[7]) / (AAbody[6] + AAbody[7]);

    // Premier facteur limitant le d?pot de prot?ines

    PDFirstLimit := PResSimulP.TabResult[32, PResSimulP.NbJSim];

    for i := 33 to 46 do

      if (i <> 35) and (i <> 39) // Ignorer 'cys' et 'tyr'

      then

        if PResSimulP.TabResult[i, PResSimulP.NbJSim] < PDFirstLimit then

          PDFirstLimit := PResSimulP.TabResult[i, PResSimulP.NbJSim];

    PResSimulP.TabResult[47, PResSimulP.NbJSim] := PDFirstLimit;

    // Besoins en ?nergie nette

    // 1) NEmAL

    FHP60 := FHPint + FHPpente * IngereAL * 1000 * NEcrois / Power(PV, 0.6);

    NEmAL := Entretien * (Standing * NEact60h + kBR * FHP60) * Power(PV, 0.6);

    PResSimulP.TabResult[71, PResSimulP.NbJSim] := NEmAL;

    // 2) NEm

    FHP60 := FHPint + FHPpente * Ingere * 1000 * NEcrois / Power(PV, 0.6);

    PResSimulP.TabResult[91, PResSimulP.NbJSim] := FHP60;

    NEm := Entretien * (Standing * NEact60h + kBR * FHP60) * Power(PV, 0.6);

    PResSimulP.TabResult[72, PResSimulP.NbJSim] := NEm;

    // R?partition de l'?nergie

    NEintakeAL := 1000 * IngereAL * NEcrois;

    PDAL := 1000 * BGompertz * p * Ln(Pmat / p);

    px1AL := (NEintakeAL - NEmAL) / NEmAL + 1;

    py1AL := PDAL * GEProtJaap;

    PResSimulP.TabResult[110, PResSimulP.NbJSim] := px1AL;

    PResSimulP.TabResult[111, PResSimulP.NbJSim] := py1AL;

    mr := (mrPV1 * PVmr2 - mrPV2 * PVmr1 - PV * mrPV1 + PV * mrPV2) /

      (-PVmr1 + PVmr2) * (NEmAL / 1000);

    PResSimulP.TabResult[51, PResSimulP.NbJSim] := mr;

    F  := 1 / 2 * (mr * power(px1AL, 2) - 2 * px1AL * py1AL - mr) /

      (-py1AL + px1AL * mr - mr);

    if (F <= 1) or (py1AL / (px1AL - 1) <= mr) then // Minimum (courbure convexe)

    begin

      F := INFINI;

      a := py1AL / (px1AL - 1);

      b := 0;

    end

    else

    if mr >= 0 then

    begin

      a := -(px1AL * mr - mr - 2 * py1AL) / (px1AL - 1);

      b := (-py1AL + px1AL * mr - mr) / (power(px1AL, 2) - 2 * px1AL + 1);

    end

    else

    begin

      a := 2 * py1AL / (F - 1);

      b := -py1AL / power((F - 1), 2);

    end;

    PResSimulP.TabResult[52, PResSimulP.NbJSim] := F;

    PResSimulP.TabResult[74, PResSimulP.NbJSim] := a;

    PResSimulP.TabResult[75, PResSimulP.NbJSim] := b;

    if px1AL < F then

      PDmaxE := a * (F - 1) + b * Power((F - 1), 2)

    else

      PDmaxE := py1AL;

    PResSimulP.TabResult[69, PResSimulP.NbJSim] := PDmaxE;

    NEintake := 1000 * Ingere * NEcrois;

    px1 := (NEintake - NEm) / NEmAL + 1;

    PResSimulP.TabResult[76, PResSimulP.NbJSim] := px1;

    if px1 < F then

      py1 := a * (px1 - 1) + b * Power(px1 - 1, 2)

    else

      py1 := PDmaxE;

    PResSimulP.TabResult[77, PResSimulP.NbJSim] := py1;

    // D?p?t de prot?ines

    if AALimit

    then

      PD := Min(py1 / GEProtJaap, PDFirstLimit)

    else

      PD := py1 / GEProtJaap;

    PResSimulP.TabResult[79, PResSimulP.NbJSim] := PD;

    EnergyPD := PD * GEProtJaap;

    PResSimulP.TabResult[66, PResSimulP.NbJSim] := EnergyPD;

    // Apport en ?nergie

    PfreeNE := 0;

    for i := 1 to 6 do

    begin

      TabProtFreeME[i] := TabDEIntake[i] * ValEnergie[i, 4] * ValEnergie[i, 2];

      TabProtFreeNE[i] := TabProtFreeME[i] * ValEnergie[i, 5];

      PfreeNE := PfreeNE + TabProtFreeNE[i];

      PResSimulP.TabResult[i + 52, PResSimulP.NbJSim] := TabProtFreeNE[i];

    end;

    PResSimulP.TabResult[59, PResSimulP.NbJSim] := PfreeNE;

    // Exc?s de prot?ines

    ExcessProt  := TabDEIntake[1] - PD;

    PResSimulP.TabResult[60, PResSimulP.NbJSim] := ExcessProt;

    ObligUrinELoss := 168 * Power(PV, 0.175);

    PResSimulP.TabResult[61, PResSimulP.NbJSim] := ObligUrinELoss;

    UrinEnergy  := ((ExcessProt / 6.25) * VarUrinELoss) + ObligUrinELoss;

    PResSimulP.TabResult[62, PResSimulP.NbJSim] := UrinEnergy;

    MEexcessProt := (ExcessProt * GEProtJaap) - UrinEnergy;

    PResSimulP.TabResult[63, PResSimulP.NbJSim] := MEexcessProt;

    NEexcessProt := MEexcessProt * kProtJaap;

    PResSimulP.TabResult[64, PResSimulP.NbJSim] := NEexcessProt;

    PDfreeNEintake := PfreeNE + NEexcessProt;

    PResSimulP.TabResult[65, PResSimulP.NbJSim] := PDfreeNEintake;

    NEintakeSim := EnergyPD + PDfreeNEintake;

    PResSimulP.TabResult[67, PResSimulP.NbJSim] := NEintakeSim;

    if Ingere <> 0 then

      PResSimulP.TabResult[88, PResSimulP.NbJSim] := NEintakeSim / (Ingere * 1000);

    MEintake := TabProtFreeME[1] + TabProtFreeME[2] + TabProtFreeME[3] +

      TabProtFreeME[4] + TabProtFreeME[5] + TabProtFreeME[6] + MEexcessProt + EnergyPD;

    PResSimulP.TabResult[86, PResSimulP.NbJSim] := MEintake;

    if Ingere <> 0 then

      PResSimulP.TabResult[87, PResSimulP.NbJSim] := MEintake / (Ingere * 1000);

    // Besoin en ?nergie pour le d?pot de prot?ines

    PDfreeNEPD := PD * GEProtJaap * NEPD;

    PResSimulP.TabResult[68, PResSimulP.NbJSim] := PDfreeNEPD;

    PDfreeNEreq := PDfreeNEPD + NEm;

    PResSimulP.TabResult[73, PResSimulP.NbJSim] := PDfreeNEreq;

    PResSimulP.TabResult[92, PResSimulP.NbJSim] := NEintakeSim - NEm;

    // D?p?t de lipides

    EnergyLD := PDfreeNEintake - PDfreeNEreq;

    LD := EnergyLD / ValEnergie[2, 2];

    PResSimulP.TabResult[80, PResSimulP.NbJSim] := LD;

    // Performances

    p  := p + PD / 1000;

    PResSimulP.TabResult[81, PResSimulP.NbJSim] := p;

    l  := l + LD / 1000;

    PResSimulP.TabResult[82, PResSimulP.NbJSim] := l;

    if (p > 0) and (l > 0) then

      // Calcul du PVV ? partir des poids de prot?ines et lipides

      PVVafter := ((Pallom * Power(p * 1000, Ballom)) +

        (Lallom * Power(l * 1000, Ballom))) / 1000

    else

    begin

      PVVafter := PVV;

      ErrSimul := True;

    end;

    PVafter := CalcPV(PVVafter);

    PResSimulP.TabResult[83, PResSimulP.NbJSim] := PVafter;

    GMQ := PVafter - PV;

    PResSimulP.TabResult[84, PResSimulP.NbJSim] := GMQ;

    //    if GMQ <> 0

    //    then

    //      PResSimulP.TabResult[85, PResSimulP.NbJSim] := Ingere / GMQ ;

    // Test de fin de simulation

    if ModeFinSim = 0 then // Dur?e

      FinSimul := PResSimulP.NbJSim >= Duree

    else // Poids vif

      FinSimul := PV >= PVFin;

    Inc(Age);

    PV := PVafter;

  until FinSimul or ErrSimul or (PResSimulP.NbJSim = MAX_LIG_PORC);

end;

end.