import diamondedge.util.*;
import diamondedge.vb.*;
import javax.swing.*;

/**
 * '###########################################################################'
 *                        MODULE : Calcul.bas                                 '
 *                  PENDULE 4.0.0   20/06/2003                                '
 *   Executer sur appuie de traitement, Calcule de la longueur des pendules   '
 * ###########################################################################'
 * sert pour les boucles
 */

public class Calcul
{
  private static int i = 0;

  static void CalculPend() throws Exception
  {
    Pend.getFrmConf().hideForm();
    if( Variable.bon.equals( "OK" ) )
    {
      Variable.RFcSup = Variable.HNewRelev;
      NouveauRelevement();
    }

    //   shared Debug$
    //... INITALISATION DE VARIABLES
    //   Debug$ = "O"
    Variable.Passage = 0;
    Variable.NePlusOptimiser = false;
    //
    //
    //   if Debug$ = "O" then
    //        Open "C:" + Travrep$ + "\debug.$$$" For Output As #1
    //   End If
    //
    //Reparti.Initialisation();
    
    Initialisation();
    
    Transfert();

    FlechesDuFilDeContact();

    //... CALCUL DE LA REACTION RA

    Variable.Cal = 0;

    for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
    {
      Variable.Som = 0;

      for( Variable.L = 1; Variable.L <= Variable.j; Variable.L++ )
      {
        Variable.Som = Variable.Som + Variable.D[Variable.L];
      }

      Variable.Cal = Variable.Cal + (Variable.Charge[Variable.j] * (Variable.Portee - Variable.Som));
    }

    if( Pend.getMDIMenu().mnuCompProtege.isSelected() == true )
    {
      Variable.Ra = ((Obj.toDouble( Pend.getfrmPorteurProtégé().TxtMas.getText() ) - Variable.Pp) * ((Variable.Portee - Variable.lg1) - Variable.lg2) * ((Variable.Portee - Variable.lg1) + Variable.lg2)) / 2;
      Variable.Ra = Variable.Cal + ((Variable.Pp * Math.pow( Variable.Portee, 2 )) / 2) + Variable.Ra;
      Variable.Ra = (Variable.Ra + (Variable.Tp * (Variable.H1 - Variable.H2)) + (Variable.PoidIsoP * Variable.DistIsoP)) / Variable.Portee;
    }
    else
    {
      Variable.Ra = (Variable.Cal + ((Variable.Pp * Math.pow( Variable.Portee, 2 )) / 2) + (Variable.Tp * (Variable.H1 - Variable.H2)) + (Variable.PoidIsoP * Variable.DistIsoP)) / Variable.Portee;

    }

    //... FLECHES DU PORTEUR AU DROIT DE CHAQUE PendULE
    Variable.ca = 0;
    Variable.cc = 0;
    Variable.cs = 0;

    for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
    {
      Variable.ca = Variable.ca + Variable.D[Variable.j];

      if( Variable.j > 1 )
      {
        Variable.cs = Variable.cs + Variable.Charge[(Variable.j - 1)];
      }

      Variable.cc = Variable.cc + (Variable.D[Variable.j] * Variable.cs);

      CalculFlechesPorteur();
      Variable.Flp[Variable.j] = Variable.FlechePorteur;
    }

    //... ENTRAXES DES CONDUCTEURS ET LONGUEUR DES PendULES
    Variable.ca = 0;

    for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
    {
      Variable.ca = Variable.ca + Variable.D[Variable.j];
      Variable.Entrax[Variable.j] = ((Variable.H1 - Variable.Flp[Variable.j]) + Variable.Flfc[Variable.j]) - Variable.Hfc;

      if( (Pend.getMDIMenu().mnuCompProtege.isSelected() == true) && (Variable.ca > Variable.lg1) && (Variable.ca < (Variable.Portee - Variable.lg2)) )
      {
        Variable.Lpend[Variable.j] = Variable.Entrax[Variable.j] + (Variable.grif1 * ((Variable.Entrax[Variable.j] >= Variable.EtxBasculePendule) ? 1 : 0));
        Variable.Lpend[Variable.j] = Variable.Lpend[Variable.j] + (Variable.grif3 * ((Variable.Entrax[Variable.j] < Variable.EtxBasculePendule) ? 1 : 0));
      }
      else
      {
        Variable.Lpend[Variable.j] = Variable.Entrax[Variable.j] + (Variable.grif1 * ((Variable.Entrax[Variable.j] >= Variable.EtxBasculePendule) ? 1 : 0));
        Variable.Lpend[Variable.j] = Variable.Lpend[Variable.j] + (Variable.grif2 * ((Variable.Entrax[Variable.j] < Variable.EtxBasculePendule) ? 1 : 0));
      }

    }




    //... DETECTION DU PLUS PETIT ENTRAXE CONDUCTEURS
    //(limite inf‚rieure = EtxMiniPendule#)
    Variable.ca = Variable.D[1];
    Variable.EtxPetitPendule = Variable.Entrax[1];
    Variable.PosPetitPendule = Variable.ca;

    for( Variable.j = 2; Variable.j <= (Variable.nep - 1); Variable.j++ )
    {
      Variable.ca = Variable.ca + Variable.D[Variable.j];

      if( (Variable.j == Variable.Pendis1) || (Variable.j == Variable.Pendis2) )
      {
        Variable.EtxPlusPetiteSuspIs = Variable.Entrax[Variable.j];
        Variable.PosPetiteSuspIs = Variable.ca;

        if( (Variable.EmcombGauche < Variable.HauteurEmcomb) || (Variable.EmcombDroit < Variable.HauteurEmcomb) )
        {
          Variable.EtxSuspMiniIs = 0.3;
        }
        else
        {
          Variable.EtxSuspMiniIs = 0.5;
        }

        if( Variable.Lpend[Variable.j] < Variable.EtxSuspMiniIs )
        {
          Variable.EtxPlusPetiteSuspIs = Variable.Entrax[Variable.j];
          Variable.PosPetiteSuspIs = Variable.ca;
        }
      }

      if( Variable.Entrax[Variable.j] < Variable.EtxPetitPendule )
      {

        Variable.EtxPetitPendule = Variable.Entrax[Variable.j];
        Variable.PosPetitPendule = Variable.ca;
      }

    }

    //... FLECHES DU PORTEUR AU DROIT DU PRO A GAUCHE
    if( (Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true) && (Variable.dpro1 != 0) && (Variable.NePlusOptimiser == false) )
    {

      Variable.j = 1;
      Variable.ca = Variable.D[Variable.j];
      Variable.cc = 0;
      Variable.cs = 0;

      if( Variable.dpro1 > Variable.D[Variable.j] )
      {

        while( Variable.ca < Variable.dpro1 )
        {
          Variable.j = Variable.j + 1;
          Variable.ca = Variable.ca + Variable.D[Variable.j];
          Variable.cs = Variable.cs + Variable.Charge[(Variable.j - 1)];
          Variable.cc = Variable.cc + (Variable.D[Variable.j] * Variable.cs);
        }

        Variable.cc = (Variable.cc - (Variable.D[Variable.j] * Variable.cs)) + ((Variable.dpro1 - (Variable.ca - Variable.D[Variable.j])) * Variable.cs);
      }
      Variable.ca = Variable.dpro1;
      CalculFlechesPorteur();
      Variable.FlpPro1 = Variable.FlechePorteur;
      Optimisation.Optimisation1();

    }

    //... FLECHES DU PORTEUR AU DROIT DU PRO A DROITE
    if( (Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true) && (Variable.dpro2 != 0) && (Variable.NePlusOptimiser == false) )
    {

      Variable.j = 1;
      Variable.ca = Variable.D[Variable.j];
      Variable.cc = 0;
      Variable.cs = 0;

      if( (Variable.Portee - Variable.dpro2) > Variable.D[Variable.j] )
      {

        while( Variable.ca < (Variable.Portee - Variable.dpro2) )
        {
          Variable.j = Variable.j + 1;
          Variable.ca = Variable.ca + Variable.D[Variable.j];
          Variable.cs = Variable.cs + Variable.Charge[(Variable.j - 1)];
          Variable.cc = Variable.cc + (Variable.D[Variable.j] * Variable.cs);
        }

        Variable.cc = (Variable.cc - (Variable.D[Variable.j] * Variable.cs)) + (((Variable.Portee - Variable.dpro2) - (Variable.ca - Variable.D[Variable.j])) * Variable.cs);
      }
      Variable.ca = Variable.Portee - Variable.dpro2;
      CalculFlechesPorteur();
      Variable.FlpPro2 = Variable.FlechePorteur;
      Optimisation.Optimisation1();

    }
    if( (Pend.getMDIMenu().mnuPorteeAiguillage.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeseparation.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeSection.isSelected() == true) || ((Pend.getMDIMenu().mnuPorteeTendeur.isSelected() == true) && (Pend.getfrmRelevement().OptNulle.isSelected() == false)) )
    {
      //... côte d'isolement sous pro gauche
      if( Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true )
      {
        if( Pend.getfrmRelevement().OptGauche.isSelected() == true )
        {
          Variable.i1 = (((Variable.HLibreGauche - Variable.HlibrePlan) - Variable.EmcombGauche) + Variable.FlpPro1) - Variable.DemiDiam;
        }
        else
        {
          Variable.i2 = (((Variable.HLibreGauche - Variable.HlibrePlan) - Variable.EmcombGauche) + Variable.FlpPro1) - Variable.DemiDiam;
        }
      }
      //... côte d'isolement sous pro droit
      if( Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true )
      {
        if( Pend.getfrmRelevement().OptDroite.isSelected() == true )
        {
          Variable.i1 = (((Variable.HLibreDroit - Variable.HlibrePlan) - Variable.EmcombGauche) + Variable.FlpPro2) - Variable.DemiDiam;
        }
        else
        {
          Variable.i2 = (((Variable.HLibreDroit - Variable.HlibrePlan) - Variable.EmcombGauche) + Variable.FlpPro2) - Variable.DemiDiam;
        }
      }
    }
    else
    {
      Variable.i1 = (((Variable.HLibreGauche - Variable.HlibrePlan) - Variable.EmcombGauche) + Variable.FlpPro1) - Variable.DemiDiam;
      Variable.i2 = (((Variable.HLibreDroit - Variable.HlibrePlan) - Variable.EmcombGauche) + Variable.FlpPro2) - Variable.DemiDiam;
    }
    //... MODIFICATION DES ENCOMBREMENTS SI NECESSAIRE
    if( (Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true) && (Variable.TropPetit == false) )
    {
      if( Variable.EtxPetitPendule < Variable.LPendMini )
      {
        JOptionPane.showMessageDialog( Screen.getActiveControl(), "La longueur du plus petit pendule est de " + Strings.format( Variable.EtxPetitPendule, "#0.0##" ) + " m ! " + " Le calcul ne peut être repris avec les cotes d'isolement minimales !" );
        Variable.TropPetit = true;
      }
    }
    if( (Variable.EtxPetitPendule < Variable.LPendMini) && (Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true) )
    {
      Variable.EmcombDroit = Variable.EmcombDroit + 0.001;
      Transfert();
    }
    if( (Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true) && (Pend.getfrmPontRoute().CheOpt.isSelected() == true) && ((Variable.i1 < Variable.NormG) || (Variable.i2 < Variable.NormG) || (Variable.i1 < Variable.NormD) || (Variable.i2 < Variable.NormD)) && (Variable.TropPetit == false) )
    {
      if( (Pend.getfrmPontRoute().OptOptimi[4].isSelected() == true) || (Pend.getfrmPontRoute().OptOptimi[1].isSelected() == true) )
      {
        if( Pend.getfrmRelevement().OptGauche.isSelected() == true )
        {
          if( Variable.i2 < Variable.NormG )
          {
            Variable.EmcombGauche = (((Variable.HLibreGauche - Variable.HlibrePlan) + Variable.FlpPro1) - Variable.DemiDiam) - Variable.NormG;
          }
        }
        else
        {
          if( (Variable.i1 < Variable.NormG) && (Variable.Changer == false) )
          {
            Variable.EmcombDroit = (((Variable.HLibreDroit - Variable.HlibrePlan) + Variable.FlpPro2) - Variable.DemiDiam) - Variable.NormD;
            if( (Variable.dpro1 > Variable.dpro2) && (Variable.dpro2 > 18) && (Variable.Changer == false) )
            {
              Variable.Changer = true;
            }
            else
            {
              Variable.EmcombDroit = Variable.EmcombDroit - 0.001;
            }
          }
          else
          {
            Variable.EmcombDroit = Variable.EmcombDroit - 0.001;
          }
        }
        if( Pend.getfrmRelevement().OptDroite.isSelected() == true )
        {
          if( (Variable.i2 < Variable.NormD) && (Variable.Changer == false) )
          {
            Variable.EmcombDroit = (((Variable.HLibreDroit - Variable.HlibrePlan) + Variable.FlpPro2) - Variable.DemiDiam) - Variable.NormD;
            if( (Variable.dpro1 > Variable.dpro2) && (Variable.dpro2 > 18) && (Variable.Changer == false) )
            {
              Variable.Changer = true;
            }
            else
            {
              Variable.EmcombDroit = Variable.EmcombDroit - 0.001;
            }
          }
          else
          {
            Variable.EmcombDroit = Variable.EmcombDroit - 0.001;
          }
        }
        else
        {
          if( Variable.i1 < Variable.NormD )
          {
            Variable.EmcombGauche = (((Variable.HLibreGauche - Variable.HlibrePlan) + Variable.FlpPro1) - Variable.DemiDiam) - Variable.NormG;
          }
        }
        if( Variable.EmcombGauche < Variable.EmcombDroit )
        {
          Variable.EmcombDroit = Variable.EmcombGauche;
        }
        if( Variable.EmcombGauche > Variable.EmcombDroit )
        {
          Variable.EmcombGauche = Variable.EmcombDroit;
        }
        Transfert();
      }
      if( Pend.getfrmPontRoute().OptOptimi[2].isSelected() == true )
      {
        if( Pend.getfrmRelevement().OptDroite.isSelected() == true )
        {
          if( (Variable.i1 < Variable.NormD) && (Variable.Changer == false) )
          {
            if( (Variable.dpro1 > Variable.dpro2) && (Variable.dpro2 > 18) && (Variable.Changer == false) )
            {
              Variable.Changer = true;
            }
            else
            {
              Variable.EmcombDroit = Variable.EmcombDroit - 0.001;
            }
          }
          else
          {
            Variable.EmcombDroit = Variable.EmcombDroit - 0.001;
          }
        }
        else
        {
          if( Variable.i2 < Variable.NormD )
          {
            if( (Variable.dpro1 > Variable.dpro2) && (Variable.dpro2 > 18) && (Variable.Changer == false) )
            {
              Variable.Changer = true;
            }
            else
            {
              Variable.EmcombDroit = Variable.EmcombDroit - 0.001;
            }
          }
          else
          {
            Variable.EmcombDroit = Variable.EmcombDroit - 0.001;
          }
        }
        Transfert();
      }
      if( Pend.getfrmPontRoute().OptOptimi[3].isSelected() == true )
      {
        if( Pend.getfrmRelevement().OptGauche.isSelected() == true )
        {
          if( (Variable.i1 < Variable.NormG) && (Variable.Changer == false) )
          {
            if( (Variable.dpro1 > Variable.dpro2) && (Variable.dpro2 > 18) && (Variable.Changer == false) )
            {
              Variable.Changer = true;
            }
            else
            {
              Variable.EmcombGauche = Variable.EmcombGauche - 0.001;
            }
          }
          else
          {
            Variable.EmcombGauche = Variable.EmcombGauche - 0.001;
          }
        }
        else
        {
          if( Variable.i2 < Variable.NormG )
          {
            if( (Variable.dpro1 > Variable.dpro2) && (Variable.dpro2 > 18) && (Variable.Changer == false) )
            {
              Variable.Changer = true;
            }
            else
            {
              Variable.EmcombGauche = Variable.EmcombGauche - 0.001;
            }
          }
          else
          {
            Variable.EmcombGauche = Variable.EmcombGauche - 0.001;
          }
        }
        Transfert();
      }
    }

    //        If MDIMenu.mnuCompOuvrage.Checked = True And (NePlusOptimiser = False And (RedEncombrG = 1 Or RedEncombrD = 1)) Then
    //                EmcombGauche = EmcombGauche + 0.01 * (RedEncombrG = 1)
    //                EmcombDroit = EmcombDroit + 0.01 * (RedEncombrD = 1)
    //
    //                If frmPontRoute.OptOptimi(1).Value = True Then
    //
    //                        If EmcombGauche - EmcombDroit > 0 Then
    //                                frmPortee.TxtValGauche.Text = EmcombDroit
    //                        Else
    //                                frmPortee.TxtValDroit.Text = EmcombGauche
    //                        End If
    //
    //                End If
    //
    //                GoTo Initialisation
    //
    //        ElseIf NePlusOptimiser = True And (AugEncombrG = 1 Or AugEncombrD = 1) Then
    //                EmcombGauche = EmcombGauche - 0.01 * (AugEncombrG = 1)
    //                EmcombGauche = EmcombDroit - 0.01 * (AugEncombrD = 1)
    //
    //                If frmPontRoute.OptOptimi(1).Value = True Then
    //
    //                        If EmcombGauche - EmcombDroit > 0 Then
    //                                EmcombGauche = EmcombDroit
    //                        Else
    //                                EmcombDroit = EmcombGauche
    //                        End If
    //
    //                End If
    //
    //                GoTo Initialisation
    //        End If
    //... DENOMBREMENT DES PENDULES PAR TYPE
    Variable.ca = 0;
    //Open "c:" + Travrep$ + "\compte.$$$" For Output As #2
    for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
    {
      Variable.entier = Math.floor( Variable.Lpend[Variable.j] * 100 );
      if( Variable.entier < 0 )
      {
        Variable.entier = Variable.entier * -1;
      }
      Variable.reste = (Variable.Lpend[Variable.j] * 100) - Variable.entier;
      Variable.long1 = Variable.entier + (-1 * ((Variable.reste >= 0.5) ? 1 : 0));
      Variable.ca = Variable.ca + Variable.D[Variable.j];

      if( (Pend.getMDIMenu().mnuCompProtege.isSelected() == true) && (Variable.ca > Variable.lg1) && (Variable.ca < (Variable.Portee - Variable.lg2)) )
      {

        if( Variable.Entrax[Variable.j] >= Variable.EtxBasculePendule )
        {

          if( Pend.getFrmParPend().OptJT[0].isSelected() == true )
          {
            Variable.PendulesPortee[4][(int)Math.rint( Variable.long1 )] = Variable.PendulesPortee[4][(int)Math.rint( Variable.long1 )] + Obj.toDouble( Pend.getfrmComptage().TxtNombre.getText() );
          }
          else if( Pend.getFrmParPend().OptJT[1].isSelected() == true )
          {
            Variable.PendulesPortee[5][(int)Math.rint( Variable.long1 )] = Variable.PendulesPortee[5][(int)Math.rint( Variable.long1 )] + Obj.toDouble( Pend.getfrmComptage().TxtNombre.getText() );
          }

        }
        else
        {
          Variable.PendulesPortee[3][(int)Math.rint( Variable.long1 )] = Variable.PendulesPortee[3][(int)Math.rint( Variable.long1 )] + Obj.toDouble( Pend.getfrmComptage().TxtNombre.getText() );
        }

      }
//      else
//      {
//
//        if( Variable.Entrax[Variable.j] >= Variable.EtxBasculePendule )
//        {
//          Variable.PendulesPortee[1][(int)Math.rint( Variable.long1 )] = Variable.PendulesPortee[1][(int)Math.rint( Variable.long1 )] + Obj.toDouble( Pend.getfrmComptage().TxtNombre.getText() );
//          //Print #2, "PendulesPortee(1," + Str$(long1) + ") : "; PendulesPortee(1, long1)
//        }
//        else
//        {
//          Variable.PendulesPortee[2][(int)Math.rint( Variable.long1 )] = Variable.PendulesPortee[2][(int)Math.rint( Variable.long1 )] + Obj.toDouble( Pend.getfrmComptage().TxtNombre.getText() );
//          //Print #2, "PendulesPortee(2," + Str$(long1) + ") : "; PendulesPortee(2, long1)
//        }
//
//      }

    }

    //Close #2
    //... FIN DU CALCUL
    //        if Debug$ = "O" then
    //                Close #1
    //        End If
    //
    Variable.Passage = 1;

    Pend.getfrmErreurRelevement().hideForm();
    Pend.getfrmComptage().hideForm();
    Pend.getfrmRelevement().hideForm();

    Pend.getfrmRehaussement().hideForm();
    Pend.getfrmPorteurProtégé().hideForm();
    Pend.getfrmIsolateurs().hideForm();
    Pend.getfrmPontRoute().hideForm();
    Pend.getFrmParaTrait().hideForm();
    Pend.getfrmPortee().hideForm();
    Pend.getfrmRepartition().hideForm();
    Pend.getfrmCaracIS().hideForm();
    if( Pend.getMDIMenu().mnuOptLot.isSelected() == false )
    {
      JOptionPane.showMessageDialog( Screen.getActiveControl(), "calcul terminé" );
    }
    if( (Pend.getMDIMenu().mnuOptLot.isSelected() == true) && (Variable.Portee < Variable.PorteeMaxi) )
    {
      JOptionPane.showMessageDialog( Screen.getActiveControl(), "calcule terminé pour la portée de " + Variable.Portee + " m!portée suivante" );
    }
    if( (Pend.getMDIMenu().mnuOptLot.isSelected() == true) && (Variable.Portee == Variable.PorteeMaxi) )
    {
      JOptionPane.showMessageDialog( Screen.getActiveControl(), "calcule terminé pour la portée de " + Variable.Portee + " m!LOT DE PORTEE TERMINEE" );
    }
    Pend.getMDIMenu().mnuTrait.setEnabled( false );
    Pend.getMDIMenu().TlbOpt.getButton(22).setEnabled( false );
    ImprimerTraitement.Resultatpapier();
    Variable.DejaFaitUnCalc = true;
    if( Pend.getMDIMenu().mnuOptLot.isSelected() == true )
    {
      Pend.getMDIMenu().StbInfo.getPanel(2).setText( "Dernière portée calculée : " + Variable.Repere + "-" + Strings.format( Variable.Portee, "#.#00" ) );
    }
    else
    {
      Pend.getMDIMenu().StbInfo.getPanel(2).setText( "Dernière portée calculée : " + Pend.getfrmPortee().TxtRepere.getText() + "-" + Strings.format( Variable.Portee, "#.#00" ) );
    }
    //pour commencé a incrémenté le pas d'une lot de portée
    Variable.Passe1 = true;
    if( (Pend.getMDIMenu().mnuOptLot.isSelected() == true) && (Variable.Portee < Variable.PorteeMaxi) )
    {
      Initialisation();
    }
    if( Pend.getMDIMenu().mnuOptAff.isSelected() == true )
    {
      if( Pend.getMDIMenu().mnuDossierEditeurAutre.isSelected() == true )
      {
        if( Pend.getMDIMenu().mnuOptLot.isSelected() == false )
        {
          if( Variable.derportee == true )
          {
            Variable.x = Runtime.getRuntime().exec( "write " + System.getProperty("user.dir") + "\\resultats\\resultat.25000.doc" );
          }
          else
          {
            Variable.x = Runtime.getRuntime().exec( "write " + System.getProperty("user.dir") + "\\resultats\\resultatder.25000.doc" );
          }
        }
        else
        {
          Variable.x = Runtime.getRuntime().exec( "write " + System.getProperty("user.dir") + "\\resultats\\resultat.25000.doc" );
        }
      }
      if( Pend.getMDIMenu().mnuDossierEditeurDefaut.isSelected() == true )
      {
        if( Pend.getMDIMenu().mnuOptLot.isSelected() == false )
        {
          Variable.x = Runtime.getRuntime().exec( "write " + System.getProperty("user.dir") + "\\resultats\\resultatder.25000.doc" );
        }
        else
        {
          Variable.x = Runtime.getRuntime().exec( "write " + System.getProperty("user.dir") + "\\resultats\\resultat.25000.doc" );
        }
      }
    }
    //Met le changement de caténaire à faux _
    // car si il ne change pas encore une fois il ne faut pas affiché les caractéristiques
    Variable.ChangeCaten = false;
    InitialisationDeb.InitTraitement();
  }
  
  private static void NouveauRelevement() 
  {
      // Flèche du fc lorsque la longueur du relèvement libre est > à la portée
      Variable.Cal = Variable.lrelev - Variable.Portee;

      for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
      {
        Variable.Flfc[Variable.j] = (((-Variable.Pfc * Math.pow( Variable.Cal, 2 )) / 2) / Variable.Tfc) + Variable.Hfc;
        Variable.Cal = Variable.Cal + Variable.D[Variable.j];
      }
  }
  
  private static void Initialisation() {
	  try {
		        Variable.Passage = Variable.Passage + 1;
		        Variable.lg1 = 0;
		        Variable.lg2 = 0;
		        Variable.H1 = 0;
		        Variable.H2 = 0;
		        Variable.EtxSuspMiniIs = 0;
		        Variable.AugEncombrG = 0;
		        Variable.xm1 = 0;
		        Variable.xm2 = 0;
		        Variable.lm = 0;
		        Variable.Flfcmil = 0;
		        Variable.L = 0;
		        Variable.poidis = 0;
		        Variable.AugEncombrD = 0;
		        Variable.Distext = 0;
		        Variable.Xn = 0;
		        Variable.Rantibal = 0;
		        Variable.Cal = 0;
		        Variable.Jjd = 0;
		        Variable.Jfd = 0;
		        Variable.RedEncombrG = 0;
		        Variable.Ald = 0;
		        Variable.CoefK = 0;
		        Variable.ii = 0;
		        Variable.i1 = 0;
		        Variable.i2 = 0;
		        Variable.Ra = 0;
		        Variable.Som = 0;
		        Variable.RedEncombrD = 0;
		        Variable.EtxPlusPetiteSuspIs = 0;
		        Variable.dec = 0;
		        Variable.nrelfcsup = 0;
		        i = 0;
		        Variable.PosPetitPendule = 0;
		        Variable.den = 0;
		        Variable.grif1 = 0;
		        Variable.grif2 = 0;
		        Variable.grif3 = 0;
		        Variable.FlechePorteur = 0;
		        Variable.reste = 0;
		        Variable.entier = 0;
		        Variable.EtxPetitPendule = 0;
		        Variable.long1 = 0;
		        Variable.ErreurIrrecuperable = 0;
		        Variable.HfcSup = 0;
		        Variable.RFcSup = 0;
		        Variable.HLibreGauche = 0;
		        Variable.HLibreDroit = 0;
		        Variable.HlibrePlan = 0;
		        Variable.dprod = 0;
		        Variable.Dprog = 0;
		        Variable.NormG = 0;
		        Variable.NormD = 0;
		        Variable.HfcSupTxt = 0;
		        Variable.NewHRelev = 0;
		        Variable.HfcSupBis = 0;
		        Variable.PoidIsoFc = 0;
		        Variable.PoidIsoP = 0;
		        Variable.DistIsoFc = 0;
		        Variable.DistIsoP = 0;
		        Variable.poidis = 0;
		        Variable.EtxBasculePendule = 0;
		        Variable.nrelfcsup1 = false;
		        Variable.TropPetit = false;
		        Variable.Changer = false;
		        if( Variable.Passe1 == false )
		        {
		          //pour ne pas commencé à incrémenté le pas
		          Variable.Passe1 = false;
		        }
		        Variable.lrelev = 0;
		        Variable.ca = 0;
		        Variable.cs = 0;
		        Variable.cc = 0;
		        Variable.k = 0;
		        Variable.dprod = 0;
		        Variable.Hlibre1 = 0;
		        Variable.Hlibre2 = 0;
		        Variable.dpro1 = 0;
		        Variable.dpro2 = 0;
		        Variable.nep = 0;
		        //poid du fil de contact
		        Variable.Pfc = new Variant( Pend.getfrmCarCaten().TxtMasFil.getText() ).toDouble();
		        // poid du porteur
		        Variable.Pp = new Variant( Pend.getfrmCarCaten().TxtMasPor.getText() ).toDouble();
		        // tension du fil de contact
		        Variable.Tfc = new Variant( Pend.getfrmCarCaten().TxtTenFil.getText() ).toDouble();
		        // tension du porteur
		        Variable.Tp = new Variant( Pend.getfrmCarCaten().TxtTenPor.getText() ).toDouble();
		        //diamètre du fil de contact
		        Variable.Dfc = new Variant( Pend.getfrmCarCaten().TxtDiaFil.getText() ).toDouble();
		        //diamètre du porteur
		        Variable.Dp = new Variant( Pend.getfrmCarCaten().TxtDiaPor.getText() ).toDouble();
		        //hauteur emcombrement
		        Variable.HauteurEmcomb = new Variant( Pend.getfrmCarCaten().TxtHauteur.getText() ).toDouble();
		        //Choix d'une autre flèche
		        Variable.FlecheAutre = Obj.toDouble( Pend.getfrmCarCaten().TxtAutre.getText() );
		        if( Pend.getMDIMenu().mnuPorteeIS.isSelected() == true )
		        {
		          Variable.nep = Variable.NewNep;
		        }
		        else
		        {
		          //nombre d'entraxe pendule
		          Variable.nep = (int)Math.rint( new Variant( Pend.getfrmRepartition().TxtNbrPend.getText() ).toDouble() );
		        }
		        if( Pend.getMDIMenu().mnuOptLot.isSelected() == false )
		        {
		          //enmcombrement de gauche
		          Variable.EmcombGauche = new Variant( Pend.getfrmPortee().TxtValGauche.getText() ).toDouble();
		          //encombremement de droite
		          Variable.EmcombDroit = new Variant( Pend.getfrmPortee().TxtValDroit.getText() ).toDouble();
		        }
		        else
		        {
		          if( Pend.getMDIMenu().mnuPorteeNormale.isSelected() == true )
		          {
		            Variable.EmcombGauche = Variable.HauteurEmcomb;
		            Variable.EmcombDroit = Variable.HauteurEmcomb;
		          }
		          else
		          {
		            //enmcombrement de gauche
		            Variable.EmcombGauche = new Variant( Pend.getfrmPortee().TxtValGauche.getText() ).toDouble();
		            //encombremement de droite
		            Variable.EmcombDroit = new Variant( Pend.getfrmPortee().TxtValDroit.getText() ).toDouble();
		          }
		        }
		        //longueur mini des pendules
		        Variable.EtxBasculePendule = Obj.toDouble( Pend.getfrmHypotheses().TxtLPnu.getText() );
		        //Poids étriers
		        Variable.Ppendp = Obj.toDouble( Pend.getfrmHypotheses().TxtPoiPorEtr.getText() );
		        //L-l du pendul classic
		        Variable.grif1 = Obj.toDouble( Pend.getfrmHypotheses().TxtCotPor.getText() );
		        //L-l du pendule étriers
		        Variable.grif2 = Obj.toDouble( Pend.getfrmHypotheses().TxtCotPorEtr.getText() );
		        Variable.PpendNu = Obj.toDouble( Pend.getfrmHypotheses().TxtPoiPor.getText() );
		        if( (Pend.getMDIMenu().mnuCaten11.isSelected() == true) || (Pend.getMDIMenu().mnuCaten10.isSelected() == true) || (Pend.getMDIMenu().mnuCaten9.isSelected() == true) || (Pend.getMDIMenu().mnuCaten8.isSelected() == true) )
		        {
		          Variable.LPendMini = new Variant( Pend.getfrmHypotheses().TxtLPnu.getText() ).toDouble();
		        }
		        else
		        {
		          Variable.LPendMini = new Variant( Pend.getfrmHypotheses().TxtNLTnu.getText() ).toDouble();
		        }

		        if( Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true )
		        {
		          Variable.dprod = new Variant( Pend.getfrmPontRoute().TxtDroitPont.getText() ).toDouble();
		          //distance entre le pont et le poteau gauche
		          Variable.Dprog = new Variant( Pend.getfrmPontRoute().TxtGauchePont.getText() ).toDouble();
		          //hauteur du pont a gauche
		          Variable.HLibreGauche = new Variant( Pend.getfrmPontRoute().TxtLibGauche.getText() ).toDouble();
		          //hauteur du pont à droite
		          Variable.HLibreDroit = new Variant( Pend.getfrmPontRoute().TxtLibDroit.getText() ).toDouble();
		          //norme de la côte d'isolement sous pro gauche
		          Variable.NormG = new Variant( Pend.getfrmPontRoute().TxtNormG.getText() ).toDouble();
		          //norme de la côte d'isolement sous pro droit
		          Variable.NormD = new Variant( Pend.getfrmPontRoute().TxtNormD.getText() ).toDouble();
		          //hauteur du plan de contact sous P.Ro
		          Variable.HlibrePlan = new Variant( Pend.getfrmPontRoute().TxtLibPlan.getText() ).toDouble();
		        }
		        if( Pend.getMDIMenu().mnuCompProtege.isSelected() == true )
		        {
		          //masse linéeique du porteur protégé
		          Variable.Ppprot = new Variant( Pend.getfrmPorteurProtégé().TxtMas.getText() ).toDouble();
		          //diamètre du porteur protégé
		          Variable.Dpprot = new Variant( Pend.getfrmPorteurProtégé().TxtDia.getText() ).toDouble();
		          //valeur gauche de la protéction porteur
		          Variable.L1 = new Variant( Pend.getfrmPorteurProtégé().TxtGauche.getText() ).toDouble();
		          //valeur droite de la protéction porteur
		          Variable.L2 = new Variant( Pend.getfrmPorteurProtégé().TxtDroite.getText() ).toDouble();
		        }
		        if( (Pend.getMDIMenu().mnuPorteeAiguillage.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeSection.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeseparation.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeTendeur.isSelected() == true) )
		        {
		          //Valeur du dernier relevement
		          Variable.RFcSup = new Variant( Pend.getfrmRelevement().TxtDroit.getText() ).toDouble();
		          //Valeur du relévement lorsque l'on est en cassé
		          Variable.HfcSupTxt = new Variant( Pend.getfrmRelevement().TxtGauche.getText() ).toDouble();
		        }
		        if( (Pend.getMDIMenu().mnuPorteeAiguillage.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeIS.isSelected() == true) )
		        {
		          //Valeur du réhaussement
		          Variable.Hfc = new Variant( Pend.getfrmRehaussement().TxtRehau.getText() ).toDouble();
		        }
		        if( (Pend.getMDIMenu().mnuPorteeAiguillage.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeSection.isSelected() == true) || ((Pend.getMDIMenu().mnuPorteeseparation.isSelected() == true) && (Pend.getfrmRelevement().CheIsolateur.isSelected() == true)) )
		        {
		          //poid de l'isolateur sur le fil de contact
		          Variable.PoidIsoFc = new Variant( Pend.getfrmIsolateurs().TxtPoidFil.getText() ).toDouble();
		          //Distance de l'isolateur Fc par rapport au poteau le plus proche
		          Variable.DistIsoFc = new Variant( Pend.getfrmIsolateurs().TxtDisFil.getText() ).toDouble();
		          //Poid de l'isolateur sur le porteur
		          Variable.PoidIsoP = new Variant( Pend.getfrmIsolateurs().TxtPoidPor.getText() ).toDouble();
		          //Distance de l'isolateur Porteur par rapport au poteau le plus proche
		          Variable.DistIsoP = new Variant( Pend.getfrmIsolateurs().TxtDisPor.getText() ).toDouble();
		        }
		        Variable.HfcSupBis = new Variant( Pend.getFrmParaTrait().TxtTolerance.getText() ).toDouble();
		        if( Pend.getMDIMenu().mnuPorteeIS.isSelected() == true )
		        {
		          //poids de l'isolateur de section pour une portée avec iso
		          Variable.poidis = new Variant( Pend.getfrmCaracIS().TxtPoids.getText() ).toDouble();
		        }



		        if( Pend.getMDIMenu().mnuPorteeIS.isSelected() == false )
		        {
		          Variable.Pendis1 = 0;
		          Variable.Pendis2 = 0;
		        }

		        for( i = 1; i <= Variable.nep; i++ )
		        {
		          Variable.Flfc[i] = 0;
		          Variable.Charge[i] = 0;

		          Variable.Pbx[i] = 0;
		          Variable.Pby[i] = 0;
		          Variable.Flp[i] = 0;
		          Variable.Entrax[i] = 0;
		          Variable.Lpend[i] = 0;
		          Variable.D[i] = 0;
		        }
		        Variable.PendulesPortee = new double[6][401];
		        for( i = 1; i <= 5; i++ )
		        {
		          for( Variable.k = 1; Variable.k <= 400; Variable.k++ )
		          {
		            Variable.PendulesPortee[i][Variable.k] = 0;
		          }
		        }
		        //chargement de différent paramètre
		        //2 if pour avoir le bon poid des isolateurs si ils sont identique
		        if( Pend.getfrmRelevement().CheIsolateur.isSelected() == true )
		        {
		          if( Pend.getfrmIsolateurs().CheIdentique.isSelected() == true )
		          {
		            Variable.PoidIsoFc = Variable.PoidIsoP;
		            Variable.DistIsoFc = Variable.DistIsoP;
		          }
		        }

		        //procedure pour donné la bonne valeur au coéfiscient de fléche
		        if( Pend.getfrmCarCaten().Option1[0].isSelected() == true )
		        {
		          Variable.CoefK = 1;
		        }
		        if( Pend.getfrmCarCaten().Option1[1].isSelected() == true )
		        {
		          Variable.CoefK = 0.5;
		        }
		        if( Pend.getfrmCarCaten().Option1[2].isSelected() == true )
		        {
		          Variable.CoefK = 0;
		        }
		        if( Pend.getfrmCarCaten().Option1[3].isSelected() == true )
		        {
		          Variable.CoefK = Variable.FlecheAutre;
		        }
		        //Mettre la bonne valeur dans grif3(valeur de la cote de montage)
		        if( Pend.getfrmHypotheses().TxtCotPorEtrPro.getText().equals( "" ) )
		        {
		          Variable.grif3 = 0;
		        }
		        else
		        {
		          Variable.grif3 = Obj.toDouble( Pend.getfrmHypotheses().TxtCotPorEtrPro.getText() );
		        }
		        if( (Pend.getMDIMenu().mnuOptLot.isSelected() == true) && (Variable.Portee < Variable.PorteeMaxi) && (Variable.Passe1 == true) )
		        {
		          Variable.PasseLot = true;
		          Variable.Portee = Variable.Portee + new Variant( Pend.getFrmLot().TxtPas.getText() ).toDouble();
		          Reparti.intervalles();
		          Variable.somme2 = 0;
		          for( Variable.j = 1; Variable.j <= 30; Variable.j++ )
		          {
		            if( Pend.getfrmRepartition().TxtRep1[Variable.j].getText().equals( "" ) )
		            {
		              Variable.somme2 = Variable.somme2 + 0;
		            }
		            else
		            {
		              Variable.somme2 = Variable.somme2 + 1;
		            }
		          }
		          Variable.nep = Variable.somme2;
		        }
		        if( (Pend.getMDIMenu().mnuOptLot.isSelected() == true) && (Variable.Portee <= Variable.PorteeMaxi) && (Variable.Passe1 == false) )
		        {
		          Reparti.intervalles();
		          Variable.somme2 = 0;
		          for( Variable.j = 1; Variable.j <= 30; Variable.j++ )
		          {
		            if( Pend.getfrmRepartition().TxtRep1[Variable.j].getText().equals( "" ) )
		            {
		              Variable.somme2 = Variable.somme2 + 0;
		            }
		            else
		            {
		              Variable.somme2 = Variable.somme2 + 1;
		            }
		          }
		          Variable.nep = Variable.somme2;
		        }
	  }
	  catch(Exception _e_) {Err.set(_e_,"Initialisation");}
  }
  
  private static void suite() {
	  try {
		  if( (Pend.getMDIMenu().mnuCompProtege.isSelected() == true) && ((Variable.ca >= Variable.lg1) || (Variable.ca <= (Variable.Portee - Variable.lg2))) )
	        {

	          if( (Pend.getFrmParPend().OptJT[1].isSelected() == true) || (Variable.i1 < (Variable.ii - (0.05 * ((Pend.getfrmPontRoute().ChePolu.isSelected() == true) ? 1 : 0)))) || (Variable.i2 < (Variable.ii - (0.05 * ((Pend.getfrmPontRoute().ChePolu.isSelected() == true) ? 1 : 0)))) )
	          {
	            Variable.Charge[Variable.j] = Variable.Charge[Variable.j] + Variable.Ppendp;
	          }
	          else
	          {
	            Variable.Charge[Variable.j] = Variable.Charge[Variable.j] + Variable.PpendNu;
	          }

	        }
	        else
	        {
	          Variable.Charge[Variable.j] = Variable.Charge[Variable.j] + Variable.PpendNu;
	        }
	  }
	  catch(Exception _e_) {Err.set(_e_,"suite");}
  }
  
  private static void Transfert() {
	  try {
		    //... TRANSFERT DES VALEURS DANS LES VARIABLES DE CALCUL
		    //
		    Variable.nep = Variable.nep;

		    if( Pend.getfrmRelevement().OptGauche.isSelected() == true )
		    {

		      for( Variable.j = 1; Variable.j <= Variable.nep; Variable.j++ )
		      {
		        Variable.D[Variable.j] = new Variant( Pend.getfrmRepartition().TxtRep1[(Variable.nep + 1) - Variable.j].getText() ).toDouble();
		      }
		      Variable.lg1 = Variable.L2;
		      Variable.lg2 = Variable.L1;

		      Variable.H1 = Variable.EmcombDroit;
		      Variable.H2 = Variable.EmcombGauche;
		      Variable.lm = 1;
		      if( Pend.getMDIMenu().mnuCompProtege.isSelected() == true )
		      {
		        Variable.xm2 = Variable.lm * ((Variable.lg1 != 0) ? 1 : 0);
		        Variable.xm1 = Variable.lm * ((Variable.lg2 != 0) ? 1 : 0);
		      }
		      if( Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true )
		      {
		        if( Variable.Dprog != 0 )
		        {
		          Variable.dpro2 = Variable.Dprog;
		          Variable.Hlibre2 = Variable.HLibreGauche;
		        }

		        if( Variable.dprod != 0 )
		        {
		          Variable.dpro1 = Variable.dprod;
		          Variable.Hlibre1 = Variable.HLibreDroit;
		        }
		      }
		      else
		      {
		        Variable.dpro1 = 0;
		        Variable.dpro2 = 0;
		        Variable.Hlibre1 = 0;
		        Variable.Hlibre2 = 0;
		      }
		    }
		    else
		    {
		      //End If
		      //If frmRelevement.OptGauche.Value = True Then
		      for( Variable.j = 1; Variable.j <= Variable.nep; Variable.j++ )
		      {
		        Variable.D[Variable.j] = new Variant( Pend.getfrmRepartition().TxtRep1[Variable.j].getText() ).toDouble();
		      }
		      Variable.lg1 = Variable.L1;
		      Variable.lg2 = Variable.L2;
		      Variable.H1 = Variable.EmcombGauche;
		      Variable.H2 = Variable.EmcombDroit;

		      if( Pend.getMDIMenu().mnuCompProtege.isSelected() == true )
		      {
		        Variable.xm1 = Variable.lm * ((Variable.lg1 != 0) ? 1 : 0);
		        Variable.xm2 = Variable.lm * ((Variable.lg2 != 0) ? 1 : 0);
		      }
		      if( Pend.getMDIMenu().mnuCompOuvrage.isSelected() == true )
		      {
		        if( Variable.Dprog != 0 )
		        {
		          Variable.dpro1 = Variable.Dprog;
		          Variable.Hlibre1 = Variable.HLibreGauche;
		        }

		        if( Variable.dprod != 0 )
		        {
		          Variable.dpro2 = Variable.dprod;
		          Variable.Hlibre2 = Variable.HLibreDroit;
		        }
		      }
		      else
		      {
		        Variable.dpro1 = 0;
		        Variable.dpro2 = 0;
		        Variable.Hlibre1 = 0;
		        Variable.Hlibre2 = 0;
		      }
		    }
	  }
	  catch (Exception _e_) {Err.set(_e_,"Transfert");}
  }
  
  //... FLECHES DU FIL DE CONTACT AU DROIT DE CHAQUE PendULE
  
  private static void FlechesDuFilDeContact() {
	    if( (Pend.getMDIMenu().mnuPorteeNormale.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeSpeciale.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeIS.isSelected() == true) || (Pend.getfrmRelevement().OptNulle.isSelected() == true) )
	    {

	      // Fleche plan de contact milieu de portee
	      Variable.Flfcmil = (Variable.Portee * Variable.CoefK) / 1000;
	      // Dist. entre pendules extremes
	      Variable.Distext = (Variable.Portee - Variable.D[1]) - Variable.D[Variable.nep];

	      if( Variable.CoefK != 0 )
	      {
	        Variable.Xn = 0;

	        for( Variable.j = 2; Variable.j <= (Variable.nep - 2); Variable.j++ )
	        {
	          Variable.Xn = Variable.Xn + Variable.D[Variable.j];
	          Variable.Flfc[Variable.j] = ((4 * Variable.Flfcmil) / Math.pow( Variable.Distext, 2 )) * Variable.Xn * (Variable.Distext - Variable.Xn);
	        }
	      }

	      Variable.Rantibal = 0;

	    }
	    else if( Pend.getfrmRelevement().OptLibre.isSelected() == true )
	    {

	      Variable.lrelev = Variable.Tfc;
	      Variable.lrelev = Variable.lrelev * (Variable.RFcSup - Variable.Hfc);
	      Variable.lrelev = Variable.lrelev - (Variable.PoidIsoFc * Variable.DistIsoFc);
	      Variable.lrelev = (Variable.lrelev * 2) / Variable.Pfc;
	      Variable.lrelev = Math.pow( Variable.lrelev, 1 / 2 );

	      Variable.HfcSup = 0;
	      // - Hfc
	      Variable.HfcSup = (Variable.Pfc * Math.pow( (Variable.lrelev - Variable.Portee), 2 )) / (2 * Variable.Tfc);
	      if( (Variable.lrelev <= Variable.Portee) || (Variable.HfcSup <= (Variable.HfcSupBis + 0.0005)) )
	      {
	        Variable.Flfc[Variable.nep] = -Variable.RFcSup + Variable.Hfc;
	        Variable.ca = 0;

	        for( Variable.j = Variable.nep; Variable.j >= 1; Variable.j-- )
	        {
	          Variable.ca = Variable.ca + Variable.D[Variable.j];

	          if( Variable.ca >= Variable.lrelev )
	          {
	            break;
	          }

	        }
	        if( Variable.j == 0 )
	        {
	          Variable.Jjd = 1;
	        }
	        else
	        {
	          Variable.Jjd = Variable.j;
	        }
	        Variable.Cal = Variable.lrelev - Variable.D[Variable.nep];

	        for( Variable.j = Variable.nep - 1; Variable.j >= Variable.Jjd; Variable.j-- )
	        {
	          Variable.Flfc[Variable.j] = ((-Variable.Pfc * Math.pow( Variable.Cal, 2 )) / 2) / Variable.Tfc;
	          Variable.Cal = Variable.Cal - Variable.D[Variable.j];
	        }

	      }
	      else
	      {
	        Variable.nrelfcsup = (((Variable.PoidIsoFc * Variable.DistIsoFc) + (Variable.Pfc * Math.pow( Variable.Portee, 2 ))) / (2 * Variable.Tfc)) + Variable.Hfc;
	        //###############################################################################
	        //a revoir pour nrelfcsup si variable ou pas
	        //a revoir por nrelfcsup si case a coché ou pas!
	        if( Variable.nrelfcsup == Variable.RFcSup )
	        {
	          Variable.nrelfcsup1 = true;
	          FlechesDuFilDeContact();
	        }
	        else
	        {
	          Variable.nrelfcsup1 = false;
	        }
	        if( Variable.Hfc > 0 )
	        {
	          Variable.NewHRelev = (Math.pow( (Variable.HfcSupBis * 2 * Variable.Tfc), (1 / 2) ) / Variable.Pfc) + Variable.Portee;
	          Variable.NewHRelev = (((Math.pow( Variable.NewHRelev, 2 ) * Variable.Pfc) + Variable.PoidIsoFc + Variable.DistIsoFc) / (2 * Variable.Tfc)) + Variable.Hfc;
	          Variable.NewHRelev = Math.floor( (Variable.NewHRelev * 1000) ) / 1000;
	        }
	        else
	        {
	          Variable.NewHRelev = (Math.pow( ((Variable.HfcSupBis - Variable.Hfc) * 2 * Variable.Tfc), (1 / 2) ) / Variable.Pfc) + Variable.Portee;
	          Variable.NewHRelev = (((Math.pow( Variable.NewHRelev, 2 ) * Variable.Pfc) + Variable.PoidIsoFc + Variable.DistIsoFc) / (2 * Variable.Tfc)) + Variable.Hfc;
	          Variable.NewHRelev = Math.floor( (Variable.NewHRelev * 1000) ) / 1000;
	        }
	        Pend.getfrmCaracIS().hideForm();
	        Pend.getfrmComptage().hideForm();
	        Pend.getfrmRelevement().hideForm();

	        Pend.getfrmRehaussement().hideForm();
	        Pend.getfrmPorteurProtégé().hideForm();
	        Pend.getfrmIsolateurs().hideForm();
	        Pend.getfrmPontRoute().hideForm();
	        Application.getCurrent().unload( Pend.getfrmErreurRelevement() );
	        Pend.getfrmErreurRelevement().showForm();
	        return;
	      }

	      Variable.Rantibal = (Variable.lrelev * Variable.Pfc) + Variable.PoidIsoFc;

	    }
	    else if( Pend.getfrmRelevement().OptCasse.isSelected() == true )
	    {
	      Variable.lrelev = Variable.Tfc;
	      Variable.lrelev = Variable.lrelev * (Variable.HfcSupTxt - Variable.Hfc);
	      Variable.lrelev = (Variable.lrelev * 2) / Variable.Pfc;
	      Variable.lrelev = Math.pow( Variable.lrelev, 1 / 2 );
	      Variable.ca = Variable.D[1];

	      for( Variable.j = 2; Variable.j <= Variable.nep; Variable.j++ )
	      {
	        Variable.ca = Variable.ca + Variable.D[Variable.j];
	        if( Variable.ca >= Variable.lrelev )
	        {
	          break;
	        }
	      }

	      Variable.Jfd = Variable.j;
	      Variable.Flfc[Variable.Jfd] = -(Variable.HfcSupTxt - Variable.Hfc);
	      Variable.Ald = Variable.Portee - Variable.ca;

	      for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
	      {
	        Variable.ca = Variable.ca - Variable.D[Variable.j];
	        if( Variable.ca <= Variable.lrelev )
	        {
	          break;
	        }
	      }

	      Variable.Jjd = Variable.j;
	      Variable.Cal = Variable.lrelev - Variable.ca;

	      for( Variable.j = Variable.Jjd; Variable.j <= (Variable.Jfd - 1); Variable.j++ )
	      {
	        Variable.Flfc[Variable.j] = ((-Variable.Pfc * Math.pow( Variable.Cal, 2 )) / 2) / Variable.Tfc;
	        Variable.Cal = Variable.Cal + Variable.D[Variable.j + 1];
	      }

	      for( Variable.j = Variable.Jfd + 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
	      {
	        Variable.Flfc[Variable.j] = Variable.Flfc[(Variable.j - 1)] - (((Variable.RFcSup - Variable.HfcSupTxt) / Variable.Ald) * Variable.D[Variable.j]);
	      }

	      Variable.Flfc[Variable.nep] = -Variable.RFcSup + Variable.Hfc;

	      Variable.Rantibal = ((Variable.Pfc * Variable.D[Variable.nep]) / 2) + ((Variable.Tfc * (Variable.Flfc[Variable.nep] - Variable.Flfc[(Variable.nep - 1)])) / Variable.D[Variable.nep]);

	      if( Variable.DistIsoFc != 0 )
	      {
	        Variable.Rantibal = Variable.Rantibal + ((Variable.DistIsoFc * (Variable.D[Variable.nep] - Variable.DistIsoFc)) / Variable.D[Variable.nep]);
	      }

	    }
	    else
	    {

	    }
	    //if Debug$ = "O" then
	    //        For k = 1 To Nep
	    //                Print #1, format; "&##&##.###"; "Flfc("; k; ") = "; Flfc(k)
	    //        Next k
	    //End If
	    //
	    //'... CHARGE EXERCEE SUR LE PORTEUR PAR CHAQUE PENDULE
	    if( Variable.lrelev > Variable.Portee )
	    {
	      Variable.ca = 0;

	      for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
	      {
	        Variable.ca = Variable.ca + Variable.D[Variable.j];

	        if( (Pend.getMDIMenu().mnuCompProtege.isSelected() == true) && ((Variable.ca >= Variable.lg1) || (Variable.ca <= (Variable.Portee - Variable.lg2))) )
	        {

	          if( (Pend.getFrmParPend().OptJT[1].isSelected() == true) || (Variable.i1 < (Variable.ii - (0.05 * ((Pend.getfrmPontRoute().ChePolu.isSelected() == true) ? 1 : 0)))) || (Variable.i2 < (Variable.ii - (0.05 * ((Pend.getfrmPontRoute().ChePolu.isSelected() == true) ? 1 : 0)))) )
	          {
	            Variable.Charge[Variable.j] = Variable.Ppendp;
	          }
	          else
	          {
	            Variable.Charge[Variable.j] = Variable.PpendNu;
	          }

	        }
	        else
	        {
	          Variable.Charge[Variable.j] = Variable.PpendNu;
	        }

	      }

	    }
	    else
	    {
	      Variable.Pbx[1] = Variable.D[1] - ((((Variable.Flfc[1] - 0) * Variable.Tfc) / (2 * Variable.D[1])) * Variable.Pfc);
	      //Pbx(1) = D(1) * Pfc
	      //                if Debug$ = "O" then
	      //                        Print #1, format; "&##&##.###"; "Pbx( 1) = "; Pbx(1)
	      //                End If
	      if( (Pend.getMDIMenu().mnuPorteeNormale.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeSpeciale.isSelected() == true) || (Pend.getMDIMenu().mnuPorteeIS.isSelected() == true) )
	      {
	        Variable.Pby[Variable.nep] = Variable.D[Variable.nep];
	      }
	      else
	      {
	        Variable.Pby[Variable.nep] = ((-((Variable.RFcSup - Variable.Hfc) + Variable.Flfc[(Variable.nep - 1)]) * Variable.Tfc) / (Variable.D[Variable.nep] * Variable.Pfc)) + ((Variable.PoidIsoP * Variable.DistIsoP) / (Variable.D[Variable.nep] * Variable.Pfc)) + (Variable.D[Variable.nep] / 2);
	      }
	      for( Variable.j = 2; Variable.j <= (Variable.nep - 1); Variable.j++ )
	      {
	        Variable.den = Variable.Flfc[Variable.j] - Variable.Flfc[(Variable.j - 1)];

	        Variable.dec = (Variable.den * Variable.Tfc) / (Variable.D[Variable.j] * Variable.Pfc);

	        Variable.Pbx[Variable.j] = (Variable.D[Variable.j] / 2) - Variable.dec;
	        Variable.Pby[Variable.j] = (Variable.D[Variable.j] / 2) + Variable.dec;

	        //                        if Debug$ = "O" then
	        //                                Print #1, format; "&##&##.###"; "Pbx("; J; ") = "; Pbx(J)
	        //                                Print #1, format; "&##&##.###"; "Pby("; J; ") = "; Pby(J)
	        //                        End If
	      }

	      //                if Debug$ = "O" then
	      //                        Print #1, format; "&##&##.###"; "Pby("; Nep; ") = "; Pby(Nep)
	      //                End If
	      Variable.ca = 0;

	      for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
	      {
	        Variable.ca = Variable.ca + Variable.D[Variable.j];
	        Variable.Charge[Variable.j] = (Variable.Pbx[Variable.j] + Variable.Pby[Variable.j + 1]) * Variable.Pfc;

	        //                        if Debug$ = "O" then
	        //                                Print #1, format; "&##&###.###"; "charge("; J; ") = "; Charge(J)
	        //                        End If
	        if( Variable.Charge[Variable.j] < -0.01 )
	        {
	          Variable.ErreurIrrecuperable = 0;

	          if( Pend.getfrmRelevement().OptNulle.isSelected() == true )
	          {

	            if( Variable.CoefK == 0 )
	            {
	              JOptionPane.showMessageDialog( Screen.getActiveControl(), "Le calcul est stoppé pour une raison indéterminée. Vérifiez les données !" );
	              Variable.ErreurIrrecuperable = 1;
	            }
	            else
	            {
	              JOptionPane.showMessageDialog( Screen.getActiveControl(), "Réaction négative sur un pendule. Ce pendule est le n." + Variable.j + ".Le calcul est repris avec un coefficient de flèche nul." );
	              Pend.getfrmCarCaten().Option1[2].setValue( true );
	              Pend.getfrmCarCaten().hideForm();
	            }
	          }
	          else
	          {

	            if( Pend.getfrmRelevement().OptGauche.isSelected() == true )
	            {
	              Variable.j = Variable.nep - Variable.j;
	            }

	            if( Pend.getfrmRelevement().OptCasse.isSelected() == true )
	            {
	              Variable.Flp[Variable.j] = Variable.Flp[Variable.j] / Variable.Tp;
	              Pend.getfrmRelevement().OptLibre.setValue( true );
	              JOptionPane.showMessageDialog( Screen.getActiveControl(), "Le calcul est repris avec relèvement libre." );
	            }
	            else
	            {
	              JOptionPane.showMessageDialog( Screen.getActiveControl(), "Vérifiez les données !" );
	              Variable.ErreurIrrecuperable = 1;
	            }

	            JOptionPane.showMessageDialog( Screen.getActiveControl(), "Réaction négative sur le pendule n." + Variable.j );

	          }





	          if( Variable.ErreurIrrecuperable == 1 )
	          {
	            suite();
	          }
	          else
	          {
	            Initialisation();
	          }

	        }
	 
	        

	      }

	      if( Pend.getMDIMenu().mnuPorteeIS.isSelected() == true )
	      {
	        Variable.Charge[(int)Math.rint( Variable.Pendis1 )] = Variable.Charge[(int)Math.rint( Variable.Pendis1 )] + (Variable.poidis / 2);
	        Variable.Charge[(int)Math.rint( Variable.Pendis2 )] = Variable.Charge[(int)Math.rint( Variable.Pendis2 )] + (Variable.poidis / 2);
	      }

	    }

	    //... adjonction de surcharges
	    //        For j = 1 To Int(nep / 2)
	    //            surcharge(j) = surcharge(j) + surcharge(nep + 1 - j)
	    //        Next j
	    //        For j = 1 To nep
	    //            surcharge(j) = surcharge(j) + surcharge(nep + 1 - j)
	    //        Next j
	    for( Variable.j = 1; Variable.j <= (Variable.nep - 1); Variable.j++ )
	    {
	      Variable.Charge[Variable.j] = Variable.Charge[Variable.j] + Variable.surcharge[Variable.j];
	    }
  }
  
  static void CalculFlechesPorteur() throws Exception
  {
    double z = 0.0;
    //FlechePorteur, portee, PortProt$, cdbl(frmporteurprotégé.TxtMas.text), lg1, lg2, xm1, xm2, Pp, Tp, Ra, ca, cc)
    //Portee = CDbl(frmRepartition.TxtPortee.Text)
    //... CALCUL DE LA FLECHE DU PORTEUR
    if( (Pend.getMDIMenu().mnuCompProtege.isSelected() == true) && (Variable.ca > Variable.lg1) && (Variable.ca < (Variable.Portee - Variable.lg2)) )
    {
      Variable.FlechePorteur = ((Variable.Ra * Variable.ca) - Variable.cc) - ((Obj.toDouble( Pend.getfrmPorteurProtégé().TxtMas.getText() ) * Math.pow( ((Variable.ca - Variable.lg1) + Variable.xm1), 2 )) / 2);
      Variable.FlechePorteur = (Variable.FlechePorteur - (Variable.Pp * (Variable.lg1 - Variable.xm1) * (Variable.ca - ((Variable.lg1 - Variable.xm1) / 2)))) / Variable.Tp;

    }
    else if( (Pend.getMDIMenu().mnuCompProtege.isSelected() == true) && (Variable.ca >= (Variable.Portee - Variable.lg2)) )
    {
      Variable.FlechePorteur = Variable.Pp * (((Variable.lg1 - Variable.xm1) * (Variable.ca - ((Variable.lg1 - Variable.xm1) / 2))) + (Math.pow( (((Variable.lg2 - Variable.xm2) - Variable.Portee) + Variable.ca), 2 ) / 2));
      z = -Obj.toDouble( Pend.getfrmPorteurProtégé().TxtMas.getText() ) * (((Variable.Portee - Variable.lg1) - Variable.lg2) + Variable.xm1 + Variable.xm2) * ((((Variable.lg2 - Variable.lg1) - Variable.Portee) / 2) + Variable.ca);
      Variable.FlechePorteur = ((((Variable.Ra * Variable.ca) - Variable.cc) - Variable.FlechePorteur) + z) / Variable.Tp;
    }
    else
    {
      Variable.FlechePorteur = (((Variable.Ra * Variable.ca) - ((Variable.Pp * Math.pow( Variable.ca, 2 )) / 2)) - Variable.cc) / Variable.Tp;
    }

  }
}