InraPorc

unit UFBesGestE ;

interface

uses

  Windows, Forms, Classes, Controls, StdCtrls, Buttons, UVariables;

type

  TFBesGestE = class(TForm)

    GBProfil: TGroupBox;

    GBResult: TGroupBox;

    GBLoge: TGroupBox;

    CBProfil: TComboBox;

    CBLoge: TComboBox;

    ChkLoge: TCheckBox;

    BBRapGest: TBitBtn;

    BBResGest: TBitBtn;

    procedure FormClose(Sender: TObject; var Action: TCloseAction);

    procedure FormActivate(Sender: TObject);

    procedure CBProfilChange(Sender: TObject);

    procedure CBLogeChange(Sender: TObject);

    procedure ChkLogeClick(Sender: TObject);

    procedure BBResGestClick(Sender: TObject);

    procedure BBRapGestClick(Sender: TObject);

    procedure FormCreate(Sender: TObject);

    procedure FormShow(Sender: TObject);

  private

    { D?clarations priv?es }

    Update, Modal: boolean;

    procedure CalcApport;

    procedure CalcResult;

  public

    { D?clarations publiques }

    AppAliTot, AppEDTot, AppEMTot, AppENTot: array[1..NB_CYCLES] of double;

    BesEMTot, BesEMEntTot, BesEMActTot, BesEMTheTot, BesEMPortTot, BesEMResTot: array[1..NB_CYCLES] of double;

    AppAli, AppED, AppEM, AppEN: array [1..NB_CYCLES, 1..DureeGest] of double;

    BesEMEnt, BesEMAct, BesEMThe, BesEMPort, BesP, BesCa: array [1..NB_CYCLES, 1..DureeGest] of double;

    AppAA, BesAA, BesAAEnt, BesAAPort, BesAARes: array[1..NB_CYCLES, 1..14, 1..DureeGest] of double;

  end;

var

  FBesGestE: TFBesGestE;

implementation

uses

  Math, gnugettext, UInit, UFindRec, UCalcul, UFResBesGestE, UFRapBesGestE;

{$R *.dfm}

{ TFBesGestE }

procedure TFBesGestE.FormCreate(Sender: TObject);

begin

  if Screen.Fonts.IndexOf('Arial Unicode MS') <> -1

  then

    Font.Name := 'Arial Unicode MS';

  TranslateComponent(Self);

  Constraints.MinWidth := 296 + (Width - ClientWidth);

  Width := Constraints.MinWidth;

  Constraints.MaxWidth := Constraints.MinWidth;

  Constraints.MinHeight := 160 + (Height - ClientHeight);

  Height := Constraints.MinHeight;

  Constraints.MaxHeight := Constraints.MinHeight;

end;

procedure TFBesGestE.FormShow(Sender: TObject);

begin

  Modal := False;

end;

procedure TFBesGestE.FormClose(Sender: TObject; var Action: TCloseAction);

begin

  Action := caFree ;

  NumWinBesGestE := -1;

end;

procedure TFBesGestE.FormActivate(Sender: TObject);

begin

  if not Modal

  then

  begin

    StringsProfilT(CBProfil.Items, False);

    StringsLogeT(CBLoge.Items, False);

  end;

end;

procedure TFBesGestE.CBProfilChange(Sender: TObject);

begin

  if CBProfil.ItemIndex = -1

  then

    CBProfil.Hint := ''

  else

  begin

    PProfilT := ListProfilT[FindIdxProfilT (CBProfil.Text)] ;

    CBProfil.Hint := PProfilT.Memo ;

    Update := TRUE ;

    if ChkLoge.Checked

    then

      ChkLogeClick (nil)

    else

      ChkLoge.Checked := TRUE ;

    CalcApport ;

    CalcResult ;

    Update := FALSE ;

    BBResGest.Enabled := TRUE ;

    BBRapGest.Enabled := TRUE ;

  end ;

end;

procedure TFBesGestE.CBLogeChange(Sender: TObject);

begin

  if CBLoge.ItemIndex = -1

  then

    CBLoge.Hint := ''

  else

  begin

    PLogeT := ListLogeT[FindIdxLogeT (CBLoge.Text)] ;

    CBLoge.Hint := PLogeT.Memo ;

    if not Update

    then

    begin

      Update := TRUE ;

      CalcResult ;

      Update := FALSE ;

    end ;

  end ;

end;

procedure TFBesGestE.ChkLogeClick(Sender: TObject);

begin

  if ChkLoge.Checked

  then

  begin

    CBLoge.Enabled := FALSE ;

    if CBProfil.ItemIndex <> -1

    then

      if not Update

      then

      begin

        Update := TRUE ;

        CBLoge.ItemIndex := CBLoge.Items.IndexOf (FindNomLogeT (PProfilT.Loge)) ;

        CBLogeChange (nil) ;

        CalcResult ;

        Update := FALSE ;

      end

      else

      begin

        CBLoge.ItemIndex := CBLoge.Items.IndexOf (FindNomLogeT (PProfilT.Loge)) ;

        CBLogeChange (nil) ;

      end ;

  end

  else

    CBLoge.Enabled := TRUE ;

end;

procedure TFBesGestE.CalcApport ;

var

  i, Cycle, Jour, AA, Unite : integer ;

  PctAli1, PctAli2, Quantite, Ingere, IngSec1, IngSec2 : double ;

  NumRuleSeqAli, NumRuleRation : integer ;

  RuleSeqAli : array[1..MAX_RULE] of RecRuleSeqAliT ;

  RuleRation : array[1..MAX_RULE] of RecRuleRationT ;

  RuleSeqAliInit, RuleRationInit, Ecart : integer ;

  RecCC1, RecCC2 : CompositionChimique ;

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

  ok : boolean ;

begin

  for Cycle := 1 to NB_CYCLES do

  begin

    PSeqAliT := ListSeqAliT[FindIdxSeqAliT (FindNomSeqAliT (PProfilT.SeqAli))] ;

    for i := 1 to PSeqAliT.NbRuleGest do

      RuleSeqAli[i] := PSeqAliT.RuleGest[i] ;

    NumRuleSeqAli := 1 ;

    RuleSeqAliInit := 1 ;

    with RuleRation[1] do

    begin

      ModeFin := -1 ;

      Equation := 0 ; // Constant

      a := PProfilT.Gest[Cycle] ;

    end ;

    Unite := PProfilT.Unite ;

    NumRuleRation := 1 ;

    RuleRationInit := 1 ;

    // Boucle des jours

    for Jour := 1 to DureeGest do

    begin

      // Aliment(s) distribu?(s)

      repeat

        ok := TRUE ;

        with RuleSeqAli[NumRuleSeqAli] do

          if ModeFin = 0

          then // Dur?e

            if (Jour - RuleSeqAliInit + 1 > ValFin) then ok := FALSE ;

        if not (ok)

        then // Changement de r?gle

        begin

          Inc (NumRuleSeqAli) ;

          RuleSeqAliInit := Jour ;

        end ;

      until ok ;

      with RuleSeqAli[NumRuleSeqAli] do

      begin

        // 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 ;

          if ModeFin = 0

          then // Dur?e

            PctAli1 := PctAli1Init + (Jour - RuleSeqAliInit) * Ecart / ValFin

          else // Fin

            PctAli1 := PctAli1Init + (Jour - RuleSeqAliInit) * Ecart / (DureeGest - RuleSeqAliInit) ;

        end ;

      end ;

      PctAli2 := 100 - PctAli1 ;

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

      repeat

        ok := TRUE ;

        with RuleRation[NumRuleRation] do

          if ModeFin = 0

          then // Dur?e

            if Jour - RuleRationInit + 1 > ValFin then ok := FALSE ;

        if not (ok)

        then // Changement de r?gle

        begin

          Inc (NumRuleRation) ;

          RuleRationInit := Jour ;

        end ;

      until ok ;

      with RuleRation[NumRuleRation] do

      begin

        // Calcul des quantit?s

        case Equation of

          0 : // Constant

            Quantite := a ;

          1 : // Lin?aire

            Quantite := a + b * (Jour - RuleRationInit) ;

          2 : // Lin?aire-plateau

            Quantite := LPvaleur (a, b, c, Jour - RuleRationInit + 1, d) ;

          3 : // Curvilin?aire

            Quantite := CLvaleur (a, c, Jour - RuleRationInit + 1, d) ;

          else

            Quantite := 0 ;

        end ;

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

        case Unite of

          1 : // ED (MJ/j)

            Ingere := Quantite

              / (PctAli1 / 100 * RecCC1.ED_T * RecCC1.MS / 1000

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

          2 : // EM (MJ/j)

            Ingere := Quantite

              / (PctAli1 / 100 * RecCC1.EM_T * RecCC1.MS / 1000

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

          3 : // EN (MJ/j)

            Ingere := Quantite

              / (PctAli1 / 100 * RecCC1.EN_T * RecCC1.MS / 1000

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

          4 : // MS (kg/j)

            Ingere := Quantite

              / (PctAli1 / 100 * RecCC1.MS / 1000

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

          else // QI (kg/j)

            Ingere := Quantite ;

        end ;

      end ;

      // Aliment ing?r?

      AppAli[Cycle, Jour] := Ingere ;

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

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

      // Energie ing?r?e

      AppED[Cycle, Jour] := IngSec1 * RecCC1.ED_T + IngSec2 * RecCC2.ED_T ;

      AppEM[Cycle, Jour] := IngSec1 * RecCC1.EM_T + IngSec2 * RecCC2.EM_T ;

      AppEN[Cycle, Jour] := IngSec1 * RecCC1.EN_T + IngSec2 * RecCC2.EN_T ;

      // Acides amin?s digestibles

      for AA := 1 to 12 do

        AppAA[Cycle, AA, Jour] := IngSec1 * TabAAtotal1[AA] * TabCUDAA1[AA] / 100

          + IngSec2 * TabAAtotal2[AA] * TabCUDAA2[AA] / 100 ;

      // met+cys

      AppAA[Cycle, 13, Jour] := AppAA[Cycle, 2, Jour] + AppAA[Cycle, 3, Jour] ;

      // phe+tyr

      AppAA[Cycle, 14, Jour] := AppAA[Cycle, 6, Jour] + AppAA[Cycle, 7, Jour] ;

    end ;

    // Totaux

    AppAliTot[Cycle] := Sum (AppAli[Cycle]) ;

    AppEDTot[Cycle] := Sum (AppED[Cycle]) ;

    AppEMTot[Cycle] := Sum (AppEM[Cycle]) ;

    AppENTot[Cycle] := Sum (AppEN[Cycle]) ;

  end ;

end ;

procedure TFBesGestE.CalcResult ;

{

const

  DELTA = 0.3 ;

  SEUIL = 0.001 ;

  MAX_TOURS = 1000 ;

}

var

  i, j, {tour, mini,} Cycle, Jour, AA, AgeSail : integer ;

  NumRuleLoge, RuleLogeInit, Ecart, Temperature : integer ;

//  delta_pmax, delta_a, delta_b : double ;

//  tab_pmax, tab_a, tab_b, tab_ecart : array[0..NB_CYCLES] of double ;

  PdsPort, PdsSail, PdsApMB, PdsAvMB, P2Sail, P2MB, NesTotaux : double ;

  EMSail, EMApMB, GMQ, PV, PFoetus, PPlacenta : double ;

  BesEMBaseTot, EMEntSail, CorrJ, CorrNR, NRUterus, NR, LysRet, LysEnt : double ;

  BesEMBase : array [1..DureeGest] of double ;

  EMPortCum : array [0..DureeGest] of double ;

  RuleLoge : array[1..MAX_RULE] of RecRuleLogeT ;

  ok : boolean ;

//  pmax, a, b : double ;

begin

{

  // Recherche des param?tres pour la courbe de poids apr?s mise-bas

  tab_pmax[0] := 0 ;

  for i := 1 to NB_CYCLES do

    with PProfilT.Truies[i] do

      if PdsApMB > tab_pmax[0]

      then

        tab_pmax[0] := PdsApMB ;

  tab_a[0] := 1.5 ;

  tab_b[0] := 1.1 ;

  delta_pmax := tab_pmax[0] * DELTA ;

  delta_a := tab_a[0] * DELTA ;

  delta_b := tab_b[0] * DELTA ;

  tour := 0 ;

  repeat

    // ?value les points

    for i := 1 to NB_CYCLES do

      tab_pmax[i] := tab_pmax[0] + Power (-1, i) * delta_pmax ;

    for i := 1 to NB_CYCLES do

      tab_a[i] := tab_a[0] + Power (-1, i) * delta_a ;

    for i := 1 to NB_CYCLES do

      tab_b[i] := tab_b[0] + Power (-1, (i + 1) div 2) * delta_b ;

    for j := 0 to NB_CYCLES do

    begin

      tab_ecart[j] := 0 ;

      for i := 1 to NB_CYCLES do

        with PProfilT.Truies[i] do

          tab_ecart[j] := tab_ecart[j] + Power (tab_pmax[j] * (1 - Exp ((- tab_a[j] / 1000) * Power (AgeSail + 114, tab_b[j]))) - PdsApMB, 2) ;

    end ;

    // recherche le meilleur point

    mini := 0 ;

    for i := 1 to NB_CYCLES do

      if tab_ecart[i] < tab_ecart[mini]

      then

        mini := i ;

    // d?termine le point central

    if mini = 0

    then

    begin

      delta_pmax := delta_pmax * 0.8 ;

      delta_a := delta_a * 0.8 ;

      delta_b := delta_b * 0.8 ;

    end

    else

    begin

      tab_pmax[0] := tab_pmax[mini] ;

      tab_a[0] := tab_a[mini] ;

      tab_b[0] := tab_b[mini] ;

    end ;

   // ?value si les crit?res de sortie sont satisfaits

    ok := (delta_pmax < Abs (tab_pmax [mini] * SEUIL))

      and (delta_a < Abs (tab_a [mini] * SEUIL))

      and (delta_b < Abs (tab_b [mini] * SEUIL)) ;

    Inc (tour) ;

  until ok or (tour > MAX_TOURS) ;

  if ok

  then

  begin

    pmax := tab_pmax[0] ;

    a := tab_a[0] ;

    b := tab_b[0] ;

  end ;

}

  for Cycle := 1 to NB_CYCLES do

  begin

    for i := 1 to PLogeT.NbRuleGest do

      RuleLoge[i] := PLogeT.RuleGest[i] ;

    NumRuleLoge := 1 ;

    RuleLogeInit := 1 ;

    AgeSail := PProfilT.Truies[Cycle].AgeSail ;

    NesTotaux := PProfilT.Porcelets[Cycle].NesTotaux ;

    PdsSail := PProfilT.Truies[Cycle].PdsSail ;

    P2Sail := PProfilT.Truies[Cycle].P2Sail ;

    P2MB := PProfilT.Truies[Cycle].P2MB ;

    // Poids port?e

    PdsPort := NesTotaux * PProfilT.Porcelets[Cycle].PdsNais ;

    // Poids apr?s mise-bas (selon ?quation)

    PdsApMB := PProfilT.pmax * (1 - Exp ((- PProfilT.a / 1000) * Power (AgeSail + DureeGest, PProfilT.b))) ;

    PdsApMB := RoundTo (PdsApMB, -1) ;

    // Poids avant mise-bas

    PdsAvMB := PdsApMB + 0.3 + 1.329 * PdsPort ;

    // Gain de poids (lin?aire)

    GMQ := (PdsAvMB - PdsSail) / DureeGest ;

    //

    // Besoins ?n?rg?tiques

    //

    // Energie pour la constitution de r?serves

    EMSail := (-256.8 + 3.2672 * PdsSail * PV2PVV + 10.992 * P2Sail) * 4.18 ;

    EMApMB := (-256.8 + 3.2672 * PdsApMB * PV2PVV + 10.992 * P2MB) * 4.18 ;

    BesEMResTot[Cycle] := (EMApMB - EMSail) / DureeGest / 0.77 ;

    EMPortCum[0] := 0 ;

    for Jour := 1 to DureeGest do

    begin

      repeat

        ok := TRUE ;

        with RuleLoge[NumRuleLoge] do

          if ModeFin = 0

          then // Dur?e

            if Jour - RuleLogeInit + 1 > ValFin then ok := FALSE ;

        if not (ok)

        then // Changement de r?gle

        begin

          Inc (NumRuleLoge) ;

          RuleLogeInit := Jour ;

        end ;

      until ok ;

      PV := PdsSail + GMQ * Jour ;

      BesEMEnt[Cycle, Jour] := Power (PV, 0.75) * EEGest

        - 0.3 * Power (PV, 0.75) * 240 / 1000 ;

      EMPortCum[Jour] := Exp (11.72 - 8.62 * Exp (-0.01382 * Jour) + 0.0932 * NesTotaux) / 1000

        * (PdsPort * 1.3 * 4.18) / (Exp (11.72 - 8.62 * Exp (-0.01382 * DureeGest) + 0.0932 * NesTotaux) / 1000) ;

      BesEMPort[Cycle, Jour] := (EMPortCum[Jour] - EMPortCum[Jour - 1]) / 0.48 ;

      BesEMBase[Jour] := BesEMEnt[Cycle, Jour] + BesEMPort[Cycle, Jour] + BesEMResTot[Cycle]

        + 0.3 * Power (PV, 0.75) * 240 / 1000 ; // Activit? de base

      BesEMAct[Cycle, Jour] := 0.3 * Power (PV, 0.75) * RuleLoge[NumRuleLoge].Act / 1000 ;

      if (RuleLoge[NumRuleLoge].Sol = 1)

      then // Paill?

        Temperature := RuleLoge[NumRuleLoge].Temp + 3

      else

        Temperature := RuleLoge[NumRuleLoge].Temp ;

      if (RuleLoge[NumRuleLoge].Typ = 1)

      then // Collectif

        if Temperature < TCICol

        then

          BesEMThe[Cycle, Jour] := (TCICol - Temperature) * Power (PV, 0.75) * EThCol / 1000

        else

          BesEMThe[Cycle, Jour] := 0

      else

        if Temperature < TCIInd

        then

          BesEMThe[Cycle, Jour] := (TCIInd - Temperature) * Power (PV, 0.75) * EThInd / 1000

        else

          BesEMThe[Cycle, Jour] := 0 ;

    end ;

    BesEMEntTot[Cycle] := Mean (BesEMEnt[Cycle]) ;

    BesEMPortTot[Cycle] := Mean (BesEMPort[Cycle]) ;

    BesEMBaseTot := Mean (BesEMBase) ;

    BesEMActTot[Cycle] := Mean (BesEMAct[Cycle]) ;

    BesEMTheTot[Cycle] := Mean (BesEMThe[Cycle]) ;

    // Besoin total en ?nergie

    BesEMTot[Cycle] := BesEMEntTot[Cycle] + BesEMActTot[Cycle] + BesEMResTot[Cycle] + BesEMPortTot[Cycle] + BesEMTheTot[Cycle] ;

    //

    // Besoins en acides amin?s

    //

    EMEntSail := Power (PdsSail, 0.75) * EEGest ;

    for Jour := 1 to DureeGest do

    begin

      PV := PdsSail + GMQ * Jour ;

      NRUterus := Exp (8.09 - 8.71 * Exp (-0.01494 * Jour) + 0.0872 * NesTotaux) / 6.25

        - Exp (8.09 - 8.71 * Exp (-0.01494 * (Jour - 1)) + 0.0872 * NesTotaux) / 6.25 ;

      if (Jour < 98)

      then

        CorrJ := Jour

      else

        CorrJ := Jour - 6 / 16 * (Jour - 98) ;

      Case cycle of

        1 : // Port?e 1

          CorrNR := 0.5708 ;

        2 : // Port?e 2

          CorrNR := 0.4345 ;

        else

          CorrNR := 0.3664 ;

      end ;

      NR := (-0.43 + 45.92 * CorrJ / 100 - 105.35 * Power (CorrJ / 100, 2) + 64.388 * Power (CorrJ / 100, 3)

        + CorrNR * (BesEMBaseTot - EMEntSail) + NRUterus) * 0.85 ;

      LysRet := NR * 6.25 * 0.067 ;

      LysEnt := power (PV, 0.75) * 0.036 ;

      // 1) Besoin total

      BesAA[Cycle, 1, Jour] := (LysRet / 0.65) + LysEnt ;

      for AA := 2 to 12 do

        BesAA[Cycle, AA, Jour] := BesAA[Cycle, 1, Jour] * ProtIdGest[AA] / 100 ;

      // met+cys

      BesAA[Cycle, 13, Jour] := BesAA[Cycle, 1, Jour] * (ProtIdGest[2] + ProtIdGest[3]) / 100 ;

      // phe+tyr

      BesAA[Cycle, 14, Jour] := BesAA[Cycle, 1, Jour] * (ProtIdGest[6] + ProtIdGest[7]) / 100 ;

      // 2) Besoin d'entretien

      BesAAEnt[Cycle, 1, Jour] := LysEnt ;

      for AA := 2 to 12 do

        BesAAEnt[Cycle, AA, Jour] := BesAAEnt[Cycle, 1, Jour] * ProtIdEnt[AA] / 100 ;

      // met+cys

      BesAAEnt[Cycle, 13, Jour] := BesAAEnt[Cycle, 1, Jour] * (ProtIdEnt[2] + ProtIdEnt[3]) / 100 ;

      // phe+tyr

      BesAAEnt[Cycle, 14, Jour] := BesAAEnt[Cycle, 1, Jour] * (ProtIdEnt[6] + ProtIdEnt[7]) / 100 ;

      // 3) Besoin pour la port?e

      for AA := 1 to 14 do

        BesAAPort[Cycle, AA, Jour] := (BesAA[Cycle, AA, Jour] - BesAAEnt[Cycle, AA, Jour]) / NR * NRUterus ;

      // 4) Besoin pour la constitution de r?serves

      for AA := 1 to 14 do

        BesAARes[Cycle, AA, Jour] := BesAA[Cycle, AA, Jour] - BesAAEnt[Cycle, AA, Jour] - BesAAPort[Cycle, AA, Jour] ;

    end ;

    //

    // Besoin en min?raux

    //

    for Jour := 1 to DureeGest do

    begin

      PV := PdsSail + GMQ * Jour ;

      PFoetus := (Exp (4.591 - 6.389 * Exp (0.02398 * (45 - Jour)) + 0.0897 * NesTotaux)

          - Exp (4.591 - 6.389 * Exp (0.02398 * (45 - (Jour - 1))) + 0.0897 * NesTotaux))

        * PdsPort * 6.25 / Exp (4.591 - 6.389 * Exp (0.02398 * (45 - DureeGest)) + 0.0897 * NesTotaux) ;

      PPlacenta := Exp (7.34264 - 1.40598 * Exp (0.0625 * (45 - Jour)) + 0.00759 * Jour + 0.06339 * NesTotaux) * 0.0096 / 23.8

        - Exp (7.34264 - 1.40598 * Exp (0.0625 * (45 - (Jour - 1))) + 0.00759 * (Jour - 1) + 0.06339 * NesTotaux) * 0.0096 / 23.8 ;

      // Phosphore digestible

      BesP[Cycle, Jour] := 10 * PV / 1000

        + (5.42 - 0.002857 * 2 * PV) * (PdsApMB - PdsSail) / DureeGest

        + PFoetus + PPlacenta ;

      // Calcium total

      BesCa[Cycle, Jour] := BesP[Cycle, Jour] * 3.6 ;

    end ;

  end ;

end ;

procedure TFBesGestE.BBResGestClick(Sender: TObject);

begin

  Modal := True;

  FResBesGestE := TFResBesGestE.Create (Self) ;

  FResBesGestE.ShowModal ;

  FResBesGestE.Release ;

  Modal := False;

end;

procedure TFBesGestE.BBRapGestClick(Sender: TObject);

begin

  Modal := True;

  FRapBesGestE := TFRapBesGestE.Create(Self);

  FRapBesGestE.QRRapport.PreviewModal ;

  FRapBesGestE.Release;

  Modal := False;

end;

end.