Remove malloc in src/solver/hydro/

src/solver/hydro/daily/h2o_j_construire_les_contraintes.cpp

@@ -39,17 +39,12 @@ void H2O_J_ConstruireLesContraintes(int NbPdt,
                                     std::vector<int>& IndicesColonnes,
                                     CORRESPONDANCE_DES_CONTRAINTES& CorrespondanceDesContraintes)
 {
-    int NombreDeContraintes;
-    int il;
-    int Pdt;
-    int NombreDeTermes;
+    int NombreDeContraintes = 0;
+    int NombreDeTermes = 0;
+    int il = 0;
 
-    NombreDeContraintes = 0;
-    il = 0;
-
-    NombreDeTermes = 0;
     IndicesDebutDeLigne[NombreDeContraintes] = il;
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
         CoefficientsDeLaMatriceDesContraintes[il] = 1.0;
         IndicesColonnes[il] = NumeroDeVariableTurbine[Pdt];
@@ -67,7 +62,7 @@ void H2O_J_ConstruireLesContraintes(int NbPdt,
     CorrespondanceDesContraintes.NumeroDeContrainteDEnergieMensuelle = NombreDeContraintes;
     NombreDeContraintes++;
 
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
         NombreDeTermes = 0;
         IndicesDebutDeLigne[NombreDeContraintes] = il;

src/solver/hydro/daily/h2o_j_construire_les_variables.cpp

@@ -47,12 +47,9 @@ void H2O_j_ConstruireLesVariables(int NbPdt,
                                   std::vector<double*>& AdresseOuPlacerLaValeurDesVariablesOptimisees,
                                   CORRESPONDANCE_DES_VARIABLES& CorrespondanceDesVariables)
 {
-    int Var;
-    int Pdt;
+    int Var = 0;
 
-    Var = 0;
-
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
         NumeroDeVariableTurbine[Pdt] = Var;
         Xmin[Var] = 0.0;

src/solver/hydro/daily/h2o_j_fonctions.h

@@ -28,7 +28,7 @@
 #ifndef __SOLVER_H2O_J_FONCTIONS__
 #define __SOLVER_H2O_J_FONCTIONS__
 
-DONNEES_MENSUELLES H2O_J_Instanciation(void);
+DONNEES_MENSUELLES* H2O_J_Instanciation(void);
 
 void H2O_J_OptimiserUnMois(DONNEES_MENSUELLES*);
 void H2O_J_Free(DONNEES_MENSUELLES*);

src/solver/hydro/daily/h2o_j_free.cpp

@@ -51,7 +51,8 @@ void H2O_J_Free(DONNEES_MENSUELLES* DonneesMensuelles)
             SPX_LibererProbleme(ProbSpx);
     }
 
-    free(ProblemeHydraulique.Probleme);
+    PROBLEME_SIMPLEXE* pb = static_cast<PROBLEME_SIMPLEXE*>(ProblemeHydraulique.Probleme);
+    delete pb;
 
     return;
 }

src/solver/hydro/daily/h2o_j_initialiser_les_bornes_des_variables.cpp

@@ -32,18 +32,14 @@
 void H2O_J_InitialiserLesBornesdesVariables(DONNEES_MENSUELLES* DonneesMensuelles,
                                             int NumeroDeProbleme)
 {
-    int NbPdt;
-    int Var;
-
-
     const std::vector<double>& TurbineMax = DonneesMensuelles->TurbineMax;
     const std::vector<double>& TurbineMin = DonneesMensuelles->TurbineMin;
     const std::vector<double>& TurbineCible = DonneesMensuelles->TurbineCible;
     std::vector<double>& Turbine = DonneesMensuelles->Turbine;
 
     PROBLEME_HYDRAULIQUE& ProblemeHydraulique = DonneesMensuelles->ProblemeHydraulique;
 
-    NbPdt = ProblemeHydraulique.NbJoursDUnProbleme[NumeroDeProbleme];
+    const int NbPdt = ProblemeHydraulique.NbJoursDUnProbleme[NumeroDeProbleme];
 
     const CORRESPONDANCE_DES_VARIABLES& CorrespondanceDesVariables
         = ProblemeHydraulique.CorrespondanceDesVariables[NumeroDeProbleme];
@@ -58,7 +54,7 @@ void H2O_J_InitialiserLesBornesdesVariables(DONNEES_MENSUELLES* DonneesMensuelle
 
     for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
-        Var = CorrespondanceDesVariables.NumeroDeVariableTurbine[Pdt];
+        int Var = CorrespondanceDesVariables.NumeroDeVariableTurbine[Pdt];
         Xmax[Var] = TurbineMax[Pdt];
 
         Xmin[Var] = std::min(TurbineMax[Pdt], std::max(TurbineCible[Pdt], TurbineMin[Pdt]));

src/solver/hydro/daily/h2o_j_initialiser_les_second_membre.cpp

@@ -30,30 +30,23 @@
 
 void H2O_J_InitialiserLeSecondMembre(DONNEES_MENSUELLES* DonneesMensuelles, int NumeroDeProbleme)
 {
-    int Pdt;
-    int Cnt;
-    int NbPdt;
-
-    int NumeroDeContrainteDEnergieMensuelle;
-
     PROBLEME_HYDRAULIQUE& ProblemeHydraulique = DonneesMensuelles->ProblemeHydraulique;
 
-    NbPdt = ProblemeHydraulique.NbJoursDUnProbleme[NumeroDeProbleme];
-
     CORRESPONDANCE_DES_CONTRAINTES& CorrespondanceDesContraintes
         = ProblemeHydraulique.CorrespondanceDesContraintes[NumeroDeProbleme];
 
-    NumeroDeContrainteDEnergieMensuelle
+    int NumeroDeContrainteDEnergieMensuelle
       = CorrespondanceDesContraintes.NumeroDeContrainteDEnergieMensuelle;
 
     std::vector<double>& SecondMembre
         = ProblemeHydraulique.ProblemeLineairePartieVariable[NumeroDeProbleme].SecondMembre;
 
     SecondMembre[NumeroDeContrainteDEnergieMensuelle] = DonneesMensuelles->TurbineDuMois;
 
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    const int NbPdt = ProblemeHydraulique.NbJoursDUnProbleme[NumeroDeProbleme];
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
-        Cnt = CorrespondanceDesContraintes.NumeroDeContrainteSurXi[Pdt];
+        int Cnt = CorrespondanceDesContraintes.NumeroDeContrainteSurXi[Pdt];
         SecondMembre[Cnt] = DonneesMensuelles->TurbineCible[Pdt];
     }
 

src/solver/hydro/daily/h2o_j_instanciation.cpp

@@ -28,11 +28,11 @@
 #include "h2o_j_donnees_mensuelles.h"
 #include "h2o_j_fonctions.h"
 
-DONNEES_MENSUELLES H2O_J_Instanciation(void)
+DONNEES_MENSUELLES* H2O_J_Instanciation(void)
 {
-    DONNEES_MENSUELLES DonneesMensuelles;
+    DONNEES_MENSUELLES* DonneesMensuelles = new DONNEES_MENSUELLES;
 
-    PROBLEME_HYDRAULIQUE& ProblemeHydraulique = DonneesMensuelles.ProblemeHydraulique;
+    PROBLEME_HYDRAULIQUE& ProblemeHydraulique = DonneesMensuelles->ProblemeHydraulique;
 
     ProblemeHydraulique.NombreDeProblemes = 4;
 
@@ -44,10 +44,10 @@ DONNEES_MENSUELLES H2O_J_Instanciation(void)
     NbJoursDUnProbleme[2] = 30;
     NbJoursDUnProbleme[3] = 31;
 
-    DonneesMensuelles.TurbineMax.assign(NbJoursDUnProbleme[3], 0.);
-    DonneesMensuelles.TurbineMin.assign(NbJoursDUnProbleme[3], 0.);
-    DonneesMensuelles.TurbineCible.assign(NbJoursDUnProbleme[3], 0.);
-    DonneesMensuelles.Turbine.assign(NbJoursDUnProbleme[3], 0.);
+    DonneesMensuelles->TurbineMax.assign(NbJoursDUnProbleme[3], 0.);
+    DonneesMensuelles->TurbineMin.assign(NbJoursDUnProbleme[3], 0.);
+    DonneesMensuelles->TurbineCible.assign(NbJoursDUnProbleme[3], 0.);
+    DonneesMensuelles->Turbine.assign(NbJoursDUnProbleme[3], 0.);
 
     int NombreDeProblemes = ProblemeHydraulique.NombreDeProblemes;
 
@@ -77,7 +77,7 @@ DONNEES_MENSUELLES H2O_J_Instanciation(void)
 
     for (int i = 0; i < NombreDeProblemes; i++)
     {
-        int NbPdt = NbJoursDUnProbleme[i];
+        const int NbPdt = NbJoursDUnProbleme[i];
 
         CorrespondanceDesVariables[i].NumeroDeVariableTurbine.assign(NbPdt, 0);
         CorrespondanceDesContraintes[i].NumeroDeContrainteSurXi.assign(NbPdt, 0);

src/solver/hydro/daily/h2o_j_lisser_les_sur_turbines.cpp

@@ -32,94 +32,83 @@
 
 void H2O_J_LisserLesSurTurbines(DONNEES_MENSUELLES* DonneesMensuelles, int NumeroDeProbleme)
 {
-    int Pdt;
-    int Cnt;
-    int NbPdt;
-    double X;
-    int Np;
-    char* Flag;
-    char LimiteAtteinte;
-    int NbCycles;
-    double SurTurbineARepartir;
-    double Xmoy;
-    double MargeMin;
-    double SurTurbine;
     PROBLEME_HYDRAULIQUE& ProblemeHydraulique = DonneesMensuelles->ProblemeHydraulique;
 
-    std::vector<double>& TurbineMax = DonneesMensuelles->TurbineMax;
-    std::vector<double>& Turbine = DonneesMensuelles->Turbine;
-    std::vector<double>& TurbineCible = DonneesMensuelles->TurbineCible;
+    auto& Turbine = DonneesMensuelles->Turbine;
+    const auto& TurbineMax = DonneesMensuelles->TurbineMax;
+    const auto& TurbineCible = DonneesMensuelles->TurbineCible;
 
-    Flag = (char*) ProblemeHydraulique.ProblemeLineairePartieVariable[NumeroDeProbleme].Xmax.data();
+    const int NbPdt = ProblemeHydraulique.NbJoursDUnProbleme[NumeroDeProbleme];
 
-    NbPdt = ProblemeHydraulique.NbJoursDUnProbleme[NumeroDeProbleme];
+    std::vector<bool> flag(NbPdt);
 
-    SurTurbineARepartir = 0.0;
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    double SurTurbineARepartir = 0.0;
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
-        Flag[Pdt] = 0;
+        flag[Pdt] = 0;
         if (Turbine[Pdt] - TurbineCible[Pdt] > ZERO)
-            Flag[Pdt] = 1;
+            flag[Pdt] = 1;
     }
 
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
-        if (Flag[Pdt] == 1)
+        if (flag[Pdt] == 1)
             SurTurbineARepartir += Turbine[Pdt] - TurbineCible[Pdt];
     }
 
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
-        Flag[Pdt] = 0;
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
+        flag[Pdt] = 0;
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
         if (TurbineMax[Pdt] - TurbineCible[Pdt] > ZERO)
-            Flag[Pdt] = 1;
+            flag[Pdt] = 1;
     }
 
-    NbCycles = 0;
+    int NbCycles = 0;
 BoucleDeRepartition:
 
-    Np = 0;
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    int Np = 0;
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
-        if (Flag[Pdt] == 1)
+        if (flag[Pdt] == 1)
             Np++;
     }
     if (Np <= 0)
     {
         return;
     }
 
-    MargeMin = 0.;
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    double MargeMin = 0.;
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
         MargeMin += TurbineMax[Pdt];
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
-        if (Flag[Pdt] == 1)
+        if (flag[Pdt] == 1)
         {
             if (TurbineMax[Pdt] - TurbineCible[Pdt] < MargeMin)
                 MargeMin = TurbineMax[Pdt] - TurbineCible[Pdt];
         }
     }
 
-    Xmoy = SurTurbineARepartir / Np;
+    double Xmoy = SurTurbineARepartir / Np;
+    double SurTurbine;
     if (Xmoy <= MargeMin)
         SurTurbine = Xmoy;
     else
         SurTurbine = MargeMin;
 
-    LimiteAtteinte = 0;
-    for (Pdt = 0; Pdt < NbPdt; Pdt++)
+    char LimiteAtteinte = 0;
+    for (int Pdt = 0; Pdt < NbPdt; Pdt++)
     {
-        if (Flag[Pdt] == 0)
+        if (flag[Pdt] == 0)
             continue;
 
         Turbine[Pdt] = TurbineCible[Pdt] + SurTurbine;
         if (TurbineMax[Pdt] - Turbine[Pdt] <= ZERO)
         {
             SurTurbineARepartir -= SurTurbine;
             LimiteAtteinte = 1;
-            Flag[Pdt] = 0;
+            flag[Pdt] = 0;
         }
     }
 

src/solver/hydro/daily/h2o_j_optimiser_un_mois.cpp

@@ -30,13 +30,10 @@
 
 void H2O_J_OptimiserUnMois(DONNEES_MENSUELLES* DonneesMensuelles)
 {
-    int NumeroDeProbleme;
-    int i;
-
     PROBLEME_HYDRAULIQUE& ProblemeHydraulique = DonneesMensuelles->ProblemeHydraulique;
 
-    NumeroDeProbleme = -1;
-    for (i = 0; i < ProblemeHydraulique.NombreDeProblemes; i++)
+    int NumeroDeProbleme = -1;
+    for (int i = 0; i < ProblemeHydraulique.NombreDeProblemes; i++)
     {
         if (DonneesMensuelles->NombreDeJoursDuMois == ProblemeHydraulique.NbJoursDUnProbleme[i])
         {
@@ -53,11 +50,8 @@ void H2O_J_OptimiserUnMois(DONNEES_MENSUELLES* DonneesMensuelles)
     DonneesMensuelles->ResultatsValides = NON;
 
     H2O_J_InitialiserLeSecondMembre(DonneesMensuelles, NumeroDeProbleme);
-
     H2O_J_InitialiserLesBornesdesVariables(DonneesMensuelles, NumeroDeProbleme);
-
     H2O_J_ResoudreLeProblemeLineaire(DonneesMensuelles, NumeroDeProbleme);
-
     H2O_J_LisserLesSurTurbines(DonneesMensuelles, NumeroDeProbleme);
 
     return;

src/solver/hydro/daily/h2o_j_resoudre_le_probleme_lineaire.cpp

@@ -48,16 +48,6 @@ extern "C"
 
 void H2O_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES* DonneesMensuelles, int NumeroDeProbleme)
 {
-    int Var;
-    double* pt;
-    char PremierPassage;
-
-
-    PROBLEME_SIMPLEXE* Probleme;
-    PROBLEME_SPX* ProbSpx;
-
-    PremierPassage = OUI;
-
     PROBLEME_HYDRAULIQUE& ProblemeHydraulique = DonneesMensuelles->ProblemeHydraulique;
 
     PROBLEME_LINEAIRE_PARTIE_VARIABLE& ProblemeLineairePartieVariable
@@ -66,23 +56,25 @@ void H2O_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES* DonneesMensuelles, int
     PROBLEME_LINEAIRE_PARTIE_FIXE& ProblemeLineairePartieFixe
         = ProblemeHydraulique.ProblemeLineairePartieFixe[NumeroDeProbleme];
 
-    ProbSpx = (PROBLEME_SPX*)ProblemeHydraulique.ProblemeSpx[NumeroDeProbleme];
+    PROBLEME_SPX* ProbSpx = (PROBLEME_SPX*)ProblemeHydraulique.ProblemeSpx[NumeroDeProbleme];
+    PROBLEME_SIMPLEXE* Probleme = (PROBLEME_SIMPLEXE*)ProblemeHydraulique.Probleme;
 
-    Probleme = (PROBLEME_SIMPLEXE*)ProblemeHydraulique.Probleme;
-    if (Probleme == NULL)
+    if (!Probleme)
     {
-        Probleme = (PROBLEME_SIMPLEXE*)malloc(sizeof(PROBLEME_SIMPLEXE));
-        if (Probleme == NULL)
+        Probleme = new(std::nothrow) PROBLEME_SIMPLEXE;
+        if (!Probleme)
         {
             DonneesMensuelles->ResultatsValides = EMERGENCY_SHUT_DOWN;
             return;
         }
         ProblemeHydraulique.Probleme = (void*)Probleme;
     }
 
+    char PremierPassage = OUI;
+
 RESOLUTION:
 
-    if (ProbSpx == NULL)
+    if (!ProbSpx)
     {
         Probleme->Contexte = SIMPLEXE_SEUL;
         Probleme->BaseDeDepartFournie = NON_SPX;
@@ -150,10 +142,8 @@ void H2O_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES* DonneesMensuelles, int
 
     ProbSpx = SPX_Simplexe(Probleme, ProbSpx);
 
-    if (ProbSpx != NULL)
-    {
+    if (ProbSpx)
         ProblemeHydraulique.ProblemeSpx[NumeroDeProbleme] = (void*)ProbSpx;
-    }
 
     ProblemeLineairePartieVariable.ExistenceDUneSolution = Probleme->ExistenceDUneSolution;
 
@@ -179,13 +169,11 @@ void H2O_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES* DonneesMensuelles, int
     {
         DonneesMensuelles->ResultatsValides = OUI;
 
-        for (Var = 0; Var < ProblemeLineairePartieFixe.NombreDeVariables; Var++)
+        for (int Var = 0; Var < ProblemeLineairePartieFixe.NombreDeVariables; Var++)
         {
-            pt = ProblemeLineairePartieVariable.AdresseOuPlacerLaValeurDesVariablesOptimisees[Var];
-            if (pt != NULL)
-            {
+            double* pt = ProblemeLineairePartieVariable.AdresseOuPlacerLaValeurDesVariablesOptimisees[Var];
+            if (pt)
                 *pt = ProblemeLineairePartieVariable.X[Var];
-            }
         }
     }
     else