diff --git a/src/solver/hydro/daily/h2o_j_donnees_optimisation.h b/src/solver/hydro/daily/h2o_j_donnees_optimisation.h index 35875499e9..7038184313 100644 --- a/src/solver/hydro/daily/h2o_j_donnees_optimisation.h +++ b/src/solver/hydro/daily/h2o_j_donnees_optimisation.h @@ -27,6 +27,18 @@ #ifndef __SOLVER_H2O_J_STRUCTURE_INTERNE__ #define __SOLVER_H2O_J_STRUCTURE_INTERNE__ +#ifdef __CPLUSPLUS +extern "C" +{ +#endif + +#include "spx_definition_arguments.h" +#include "spx_fonctions.h" + +#ifdef __CPLUSPLUS +} +#endif + #define LINFINI 1.e+80 #define JOURS_28 28 @@ -127,9 +139,7 @@ struct PROBLEME_HYDRAULIQUE std::vector ProblemeLineairePartieFixe; std::vector ProblemeLineairePartieVariable; - std::vector ProblemeSpx; /* Il y en a 1 par reservoir. Un probleme couvre 1 mois */ - void* Probleme; /* Le probleme en cours passe au simplexe */ - + std::vector ProblemeSpx; /* Il y en a 1 par reservoir. Un probleme couvre 1 mois */ }; #endif diff --git a/src/solver/hydro/daily/h2o_j_instanciation.cpp b/src/solver/hydro/daily/h2o_j_instanciation.cpp index 7065756843..f9b6f06beb 100644 --- a/src/solver/hydro/daily/h2o_j_instanciation.cpp +++ b/src/solver/hydro/daily/h2o_j_instanciation.cpp @@ -61,8 +61,6 @@ DONNEES_MENSUELLES* H2O_J_Instanciation(void) ProblemeHydraulique.ProblemeSpx.assign(NombreDeProblemes, nullptr); - ProblemeHydraulique.Probleme = NULL; - std::vector& CorrespondanceDesVariables = ProblemeHydraulique.CorrespondanceDesVariables; diff --git a/src/solver/hydro/daily/h2o_j_resoudre_le_probleme_lineaire.cpp b/src/solver/hydro/daily/h2o_j_resoudre_le_probleme_lineaire.cpp index c81ce6d1b5..48a9be0802 100644 --- a/src/solver/hydro/daily/h2o_j_resoudre_le_probleme_lineaire.cpp +++ b/src/solver/hydro/daily/h2o_j_resoudre_le_probleme_lineaire.cpp @@ -25,18 +25,6 @@ ** SPDX-License-Identifier: licenceRef-GPL3_WITH_RTE-Exceptions */ -#ifdef __CPLUSPLUS -extern "C" -{ -#endif - -#include "spx_definition_arguments.h" -#include "spx_fonctions.h" - -#ifdef __CPLUSPLUS -} -#endif - #include "h2o_j_donnees_mensuelles.h" #include "h2o_j_fonctions.h" @@ -58,15 +46,9 @@ void H2O_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES* DonneesMensuelles, int PROBLEME_LINEAIRE_PARTIE_FIXE& ProblemeLineairePartieFixe = ProblemeHydraulique.ProblemeLineairePartieFixe[NumeroDeProbleme]; - PROBLEME_SPX* ProbSpx = (PROBLEME_SPX*)ProblemeHydraulique.ProblemeSpx[NumeroDeProbleme]; + PROBLEME_SPX* ProbSpx = ProblemeHydraulique.ProblemeSpx[NumeroDeProbleme]; std::unique_ptr Probleme = std::make_unique(); - if (!Probleme) - { - DonneesMensuelles->ResultatsValides = EMERGENCY_SHUT_DOWN; - return; - } - bool PremierPassage = true; RESOLUTION: @@ -140,7 +122,7 @@ void H2O_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES* DonneesMensuelles, int ProbSpx = SPX_Simplexe(Probleme.get(), ProbSpx); if (ProbSpx) - ProblemeHydraulique.ProblemeSpx[NumeroDeProbleme] = (void*)ProbSpx; + ProblemeHydraulique.ProblemeSpx[NumeroDeProbleme] = ProbSpx; ProblemeLineairePartieVariable.ExistenceDUneSolution = Probleme->ExistenceDUneSolution; diff --git a/src/solver/hydro/daily2/h2o2_j_apply_costs.cpp b/src/solver/hydro/daily2/h2o2_j_apply_costs.cpp index 47ff5eee01..fef95fe20b 100644 --- a/src/solver/hydro/daily2/h2o2_j_apply_costs.cpp +++ b/src/solver/hydro/daily2/h2o2_j_apply_costs.cpp @@ -31,55 +31,49 @@ void H2O2_J_apply_costs(const Hydro_problem_costs& h2o2_costs, DONNEES_MENSUELLES_ETENDUES& problem) { - int NombreDeProblemes; - PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE** ProblemeLineaireEtenduPartieFixe; - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU** CorrespondanceDesVariables; - int NbPdt; - int* NbJoursDUnProbleme; - - NombreDeProblemes = problem.ProblemeHydrauliqueEtendu->NombreDeProblemes; - ProblemeLineaireEtenduPartieFixe - = problem.ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe; - CorrespondanceDesVariables = problem.ProblemeHydrauliqueEtendu->CorrespondanceDesVariables; - NbJoursDUnProbleme = problem.ProblemeHydrauliqueEtendu->NbJoursDUnProbleme; + int NombreDeProblemes = problem.ProblemeHydrauliqueEtendu.NombreDeProblemes; + auto& ProblemeLineaireEtenduPartieFixe + = problem.ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieFixe; + auto& CorrespondanceDesVariables = problem.ProblemeHydrauliqueEtendu.CorrespondanceDesVariables; + const auto& NbJoursDUnProbleme = problem.ProblemeHydrauliqueEtendu.NbJoursDUnProbleme; for (int pb_num = 0; pb_num < NombreDeProblemes; pb_num++) { - NbPdt = NbJoursDUnProbleme[pb_num]; + int NbPdt = NbJoursDUnProbleme[pb_num]; - for (int var = 0; var < ProblemeLineaireEtenduPartieFixe[pb_num]->NombreDeVariables; var++) - ProblemeLineaireEtenduPartieFixe[pb_num]->CoutLineaire[var] = 0.0; + for (int var = 0; var < ProblemeLineaireEtenduPartieFixe[pb_num].NombreDeVariables; var++) + ProblemeLineaireEtenduPartieFixe[pb_num].CoutLineaire[var] = 0.0; for (int Pdt = 0; Pdt < NbPdt; Pdt++) ProblemeLineaireEtenduPartieFixe[pb_num] - ->CoutLineaire[CorrespondanceDesVariables[pb_num]->NumeroVar_niveauxFinJours[Pdt]] + .CoutLineaire[CorrespondanceDesVariables[pb_num].NumeroVar_niveauxFinJours[Pdt]] = h2o2_costs.get_end_days_levels_cost(); for (int Pdt = 0; Pdt < NbPdt; Pdt++) ProblemeLineaireEtenduPartieFixe[pb_num] - ->CoutLineaire[CorrespondanceDesVariables[pb_num]->NumeroVar_overflow[Pdt]] + .CoutLineaire[CorrespondanceDesVariables[pb_num].NumeroVar_overflow[Pdt]] = h2o2_costs.get_overflow_cost(); for (int Pdt = 0; Pdt < NbPdt; Pdt++) ProblemeLineaireEtenduPartieFixe[pb_num] - ->CoutLineaire[CorrespondanceDesVariables[pb_num]->NumeroVar_deviations[Pdt]] + .CoutLineaire[CorrespondanceDesVariables[pb_num].NumeroVar_deviations[Pdt]] = h2o2_costs.get_deviations_cost(); for (int Pdt = 0; Pdt < NbPdt; Pdt++) ProblemeLineaireEtenduPartieFixe[pb_num] - ->CoutLineaire[CorrespondanceDesVariables[pb_num]->NumeroVar_violations[Pdt]] + .CoutLineaire[CorrespondanceDesVariables[pb_num].NumeroVar_violations[Pdt]] = h2o2_costs.get_violations_cost(); ProblemeLineaireEtenduPartieFixe[pb_num] - ->CoutLineaire[CorrespondanceDesVariables[pb_num]->NumeroVar_waste] + .CoutLineaire[CorrespondanceDesVariables[pb_num].NumeroVar_waste] = h2o2_costs.get_waste_cost(); ProblemeLineaireEtenduPartieFixe[pb_num] - ->CoutLineaire[CorrespondanceDesVariables[pb_num]->NumeroVar_deviationMax] + .CoutLineaire[CorrespondanceDesVariables[pb_num].NumeroVar_deviationMax] = h2o2_costs.get_deviationMax_cost(); ProblemeLineaireEtenduPartieFixe[pb_num] - ->CoutLineaire[CorrespondanceDesVariables[pb_num]->NumeroVar_violationMax] + .CoutLineaire[CorrespondanceDesVariables[pb_num].NumeroVar_violationMax] = h2o2_costs.get_violationMax_cost(); } } diff --git a/src/solver/hydro/daily2/h2o2_j_construire_les_contraintes.cpp b/src/solver/hydro/daily2/h2o2_j_construire_les_contraintes.cpp index 2f97ba4ffb..57cdddd6af 100644 --- a/src/solver/hydro/daily2/h2o2_j_construire_les_contraintes.cpp +++ b/src/solver/hydro/daily2/h2o2_j_construire_les_contraintes.cpp @@ -30,30 +30,26 @@ void H2O2_J_ConstruireLesContraintes( int NbPdt, - int* IndicesDebutDeLigne, - char* Sens, - int* NombreDeTermesDesLignes, - double* CoefficientsDeLaMatriceDesContraintes, - int* IndicesColonnes, - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU* CorrespondanceDesVariables) + std::vector& IndicesDebutDeLigne, + std::vector& Sens, + std::vector& NombreDeTermesDesLignes, + std::vector& CoefficientsDeLaMatriceDesContraintes, + std::vector& IndicesColonnes, + CORRESPONDANCE_DES_VARIABLES_PB_ETENDU& CorrespondanceDesVariables) { - int NombreDeContraintes; - int il; - int Pdt; - - NombreDeContraintes = 0; - il = 0; + int NombreDeContraintes = 0; + int il = 0; IndicesDebutDeLigne[NombreDeContraintes] = il; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_Turbine[0]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_Turbine[0]; il++; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_niveauxFinJours[0]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_niveauxFinJours[0]; il++; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_overflow[0]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_overflow[0]; il++; Sens[NombreDeContraintes] = '='; @@ -61,24 +57,24 @@ void H2O2_J_ConstruireLesContraintes( NombreDeContraintes++; - for (Pdt = 1; Pdt < NbPdt; Pdt++) + for (int Pdt = 1; Pdt < NbPdt; Pdt++) { IndicesDebutDeLigne[NombreDeContraintes] = il; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_Turbine[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_Turbine[Pdt]; il++; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_niveauxFinJours[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_niveauxFinJours[Pdt]; il++; CoefficientsDeLaMatriceDesContraintes[il] = -1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_niveauxFinJours[Pdt - 1]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_niveauxFinJours[Pdt - 1]; il++; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_overflow[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_overflow[Pdt]; il++; Sens[NombreDeContraintes] = '='; @@ -88,31 +84,31 @@ void H2O2_J_ConstruireLesContraintes( IndicesDebutDeLigne[NombreDeContraintes] = il; - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_Turbine[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_Turbine[Pdt]; il++; } CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_waste; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_waste; il++; Sens[NombreDeContraintes] = '='; NombreDeTermesDesLignes[NombreDeContraintes] = NbPdt + 1; NombreDeContraintes++; - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { IndicesDebutDeLigne[NombreDeContraintes] = il; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_Turbine[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_Turbine[Pdt]; il++; CoefficientsDeLaMatriceDesContraintes[il] = -1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_deviations[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_deviations[Pdt]; il++; Sens[NombreDeContraintes] = '<'; @@ -120,16 +116,16 @@ void H2O2_J_ConstruireLesContraintes( NombreDeContraintes++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { IndicesDebutDeLigne[NombreDeContraintes] = il; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_Turbine[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_Turbine[Pdt]; il++; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_deviations[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_deviations[Pdt]; il++; Sens[NombreDeContraintes] = '>'; @@ -137,16 +133,16 @@ void H2O2_J_ConstruireLesContraintes( NombreDeContraintes++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { IndicesDebutDeLigne[NombreDeContraintes] = il; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_deviations[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_deviations[Pdt]; il++; CoefficientsDeLaMatriceDesContraintes[il] = -1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_deviationMax; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_deviationMax; il++; Sens[NombreDeContraintes] = '<'; @@ -154,16 +150,16 @@ void H2O2_J_ConstruireLesContraintes( NombreDeContraintes++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { IndicesDebutDeLigne[NombreDeContraintes] = il; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_niveauxFinJours[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_niveauxFinJours[Pdt]; il++; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_violations[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_violations[Pdt]; il++; Sens[NombreDeContraintes] = '>'; @@ -171,16 +167,16 @@ void H2O2_J_ConstruireLesContraintes( NombreDeContraintes++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { IndicesDebutDeLigne[NombreDeContraintes] = il; CoefficientsDeLaMatriceDesContraintes[il] = 1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_violations[Pdt]; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_violations[Pdt]; il++; CoefficientsDeLaMatriceDesContraintes[il] = -1.0; - IndicesColonnes[il] = CorrespondanceDesVariables->NumeroVar_violationMax; + IndicesColonnes[il] = CorrespondanceDesVariables.NumeroVar_violationMax; il++; Sens[NombreDeContraintes] = '<'; diff --git a/src/solver/hydro/daily2/h2o2_j_construire_les_variables.cpp b/src/solver/hydro/daily2/h2o2_j_construire_les_variables.cpp index a30d3cc489..3543e733e2 100644 --- a/src/solver/hydro/daily2/h2o2_j_construire_les_variables.cpp +++ b/src/solver/hydro/daily2/h2o2_j_construire_les_variables.cpp @@ -40,92 +40,89 @@ extern "C" void H2O2_j_ConstruireLesVariables( int NbPdt, - DONNEES_MENSUELLES_ETENDUES* DonneesMensuellesEtendues, - double* Xmin, - double* Xmax, - int* TypeDeVariable, - double** AdresseOuPlacerLaValeurDesVariablesOptimisees, - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU* CorrespondanceDesVariables) + DONNEES_MENSUELLES_ETENDUES& DonneesMensuellesEtendues, + std::vector& Xmin, + std::vector& Xmax, + std::vector& TypeDeVariable, + std::vector& AdresseOuPlacerLaValeurDesVariablesOptimisees, + CORRESPONDANCE_DES_VARIABLES_PB_ETENDU& CorrespondanceDesVariables) { - int Var; - int Pdt; + int Var = 0; - Var = 0; - - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - CorrespondanceDesVariables->NumeroVar_Turbine[Pdt] = Var; + CorrespondanceDesVariables.NumeroVar_Turbine[Pdt] = Var; Xmin[Var] = 0.0; Xmax[Var] = 0.0; TypeDeVariable[Var] = VARIABLE_BORNEE_DES_DEUX_COTES; AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] - = &(DonneesMensuellesEtendues->Turbine[Pdt]); + = &(DonneesMensuellesEtendues.Turbine[Pdt]); Var++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - CorrespondanceDesVariables->NumeroVar_niveauxFinJours[Pdt] = Var; + CorrespondanceDesVariables.NumeroVar_niveauxFinJours[Pdt] = Var; Xmin[Var] = 0.0; Xmax[Var] = 1.0; TypeDeVariable[Var] = VARIABLE_BORNEE_DES_DEUX_COTES; AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] - = &(DonneesMensuellesEtendues->niveauxFinJours[Pdt]); + = &(DonneesMensuellesEtendues.niveauxFinJours[Pdt]); Var++; } - CorrespondanceDesVariables->NumeroVar_waste = Var; + CorrespondanceDesVariables.NumeroVar_waste = Var; Xmin[Var] = 0.0; Xmax[Var] = LINFINI; TypeDeVariable[Var] = VARIABLE_BORNEE_INFERIEUREMENT; - AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] = &(DonneesMensuellesEtendues->waste); + AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] = &(DonneesMensuellesEtendues.waste); Var++; - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - CorrespondanceDesVariables->NumeroVar_overflow[Pdt] = Var; + CorrespondanceDesVariables.NumeroVar_overflow[Pdt] = Var; Xmin[Var] = 0.0; Xmax[Var] = LINFINI; TypeDeVariable[Var] = VARIABLE_BORNEE_INFERIEUREMENT; AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] - = &(DonneesMensuellesEtendues->overflows[Pdt]); + = &(DonneesMensuellesEtendues.overflows[Pdt]); Var++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - CorrespondanceDesVariables->NumeroVar_deviations[Pdt] = Var; + CorrespondanceDesVariables.NumeroVar_deviations[Pdt] = Var; Xmin[Var] = 0.0; Xmax[Var] = LINFINI; TypeDeVariable[Var] = VARIABLE_BORNEE_INFERIEUREMENT; AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] - = &(DonneesMensuellesEtendues->deviations[Pdt]); + = &(DonneesMensuellesEtendues.deviations[Pdt]); Var++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - CorrespondanceDesVariables->NumeroVar_violations[Pdt] = Var; + CorrespondanceDesVariables.NumeroVar_violations[Pdt] = Var; Xmin[Var] = 0.0; Xmax[Var] = LINFINI; TypeDeVariable[Var] = VARIABLE_BORNEE_INFERIEUREMENT; AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] - = &(DonneesMensuellesEtendues->violations[Pdt]); + = &(DonneesMensuellesEtendues.violations[Pdt]); Var++; } - CorrespondanceDesVariables->NumeroVar_deviationMax = Var; + CorrespondanceDesVariables.NumeroVar_deviationMax = Var; Xmin[Var] = 0.0; Xmax[Var] = LINFINI; TypeDeVariable[Var] = VARIABLE_BORNEE_INFERIEUREMENT; - AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] = &(DonneesMensuellesEtendues->deviationMax); + AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] = &(DonneesMensuellesEtendues.deviationMax); Var++; - CorrespondanceDesVariables->NumeroVar_violationMax = Var; + CorrespondanceDesVariables.NumeroVar_violationMax = Var; Xmin[Var] = 0.0; Xmax[Var] = LINFINI; TypeDeVariable[Var] = VARIABLE_BORNEE_INFERIEUREMENT; - AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] = &(DonneesMensuellesEtendues->violationMax); + AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] = &(DonneesMensuellesEtendues.violationMax); Var++; return; diff --git a/src/solver/hydro/daily2/h2o2_j_donnees_mensuelles.h b/src/solver/hydro/daily2/h2o2_j_donnees_mensuelles.h index 4820bf9ee3..aae31e224e 100644 --- a/src/solver/hydro/daily2/h2o2_j_donnees_mensuelles.h +++ b/src/solver/hydro/daily2/h2o2_j_donnees_mensuelles.h @@ -44,13 +44,13 @@ typedef struct avoir appele H2O2_J_Instanciation */ int NombreDeJoursDuMois; /* A renseigner par l'appelant */ double TurbineDuMois; /* A renseigner par l'appelant (somme des turbines cibles du mois) */ - double* TurbineMax; /* A renseigner par l'appelant : 1 valeur par jour */ - double* TurbineMin; /*Minimum Hourly Hydro-Storage Generation*/ - double* TurbineCible; /* A renseigner par l'appelant : 1 valeur par jour */ + std::vector TurbineMax; /* A renseigner par l'appelant : 1 valeur par jour */ + std::vector TurbineMin; /*Minimum Hourly Hydro-Storage Generation*/ + std::vector TurbineCible; /* A renseigner par l'appelant : 1 valeur par jour */ double reservoirCapacity; double NiveauInitialDuMois; - double* niveauBas; - double* apports; + std::vector niveauBas; + std::vector apports; /* Les resultats */ char ResultatsValides; /* Vaut: @@ -59,11 +59,11 @@ typedef struct EMERGENCY_SHUT_DOWN si la resolution du probleme a donne lieu a une erreur interne */ - double* Turbine; /* Resultat a recuperer par l'appelant */ - double* niveauxFinJours; - double* overflows; - double* deviations; - double* violations; + std::vector Turbine; /* Resultat a recuperer par l'appelant */ + std::vector niveauxFinJours; + std::vector overflows; + std::vector deviations; + std::vector violations; double deviationMax; double violationMax; double waste; @@ -73,7 +73,7 @@ typedef struct /******************************************************************************************/ /* Problemes internes (utilise uniquement par l'optimisation) */ - PROBLEME_HYDRAULIQUE_ETENDU* ProblemeHydrauliqueEtendu; + PROBLEME_HYDRAULIQUE_ETENDU ProblemeHydrauliqueEtendu; } DONNEES_MENSUELLES_ETENDUES; #endif diff --git a/src/solver/hydro/daily2/h2o2_j_donnees_optimisation.h b/src/solver/hydro/daily2/h2o2_j_donnees_optimisation.h index ebe098de3a..b64abc1dd1 100644 --- a/src/solver/hydro/daily2/h2o2_j_donnees_optimisation.h +++ b/src/solver/hydro/daily2/h2o2_j_donnees_optimisation.h @@ -27,6 +27,18 @@ #ifndef __SOLVER_H2O2_J_STRUCTURE_INTERNE__ #define __SOLVER_H2O2_J_STRUCTURE_INTERNE__ +#ifdef __CPLUSPLUS +extern "C" +{ +#endif + +#include "spx_definition_arguments.h" +#include "spx_fonctions.h" + +#ifdef __CPLUSPLUS +} + +#endif #include "../daily/h2o_j_donnees_optimisation.h" #include #include @@ -46,8 +58,8 @@ typedef struct { int NombreDeVariables; - double* CoutLineaire; - int* TypeDeVariable; /* Indicateur du type de variable, il ne doit prendre que les suivantes + std::vector CoutLineaire; + std::vector TypeDeVariable; /* Indicateur du type de variable, il ne doit prendre que les suivantes (voir le fichier spx_constantes_externes.h mais ne jamais utiliser les valeurs explicites des constantes): VARIABLE_FIXE , @@ -58,11 +70,11 @@ typedef struct */ /* La matrice des contraintes */ int NombreDeContraintes; - char* Sens; - int* IndicesDebutDeLigne; - int* NombreDeTermesDesLignes; - double* CoefficientsDeLaMatriceDesContraintes; - int* IndicesColonnes; + std::vector Sens; + std::vector IndicesDebutDeLigne; + std::vector NombreDeTermesDesLignes; + std::vector CoefficientsDeLaMatriceDesContraintes; + std::vector IndicesColonnes; int NombreDeTermesAlloues; } PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE; @@ -72,15 +84,15 @@ typedef struct /* Donnees variables de la matrice des contraintes */ /* On met quand-meme les bornes dans la partie variable pour le cas ou on voudrait avoir un jour des bornes min et max variables dans le temps et en fonction des reservoirs */ - double* Xmin; - double* Xmax; - double* SecondMembre; + std::vector Xmin; + std::vector Xmax; + std::vector SecondMembre; /* Tableau de pointeur a des doubles. Ce tableau est parallele a X, il permet de renseigner directement les structures de description du reseau avec les resultats contenus dans X */ - double** AdresseOuPlacerLaValeurDesVariablesOptimisees; + std::vector AdresseOuPlacerLaValeurDesVariablesOptimisees; /* Resultat */ - double* X; + std::vector X; /* En Entree ou en Sortie */ int ExistenceDUneSolution; /* En sortie, vaut : OUI_SPX s'il y a une solution, @@ -92,25 +104,25 @@ typedef struct pas de solution */ - int* PositionDeLaVariable; /* Vecteur a passer au Simplexe pour recuperer la base optimale */ - int* ComplementDeLaBase; /* Vecteur a passer au Simplexe pour recuperer la base optimale */ - double* CoutsReduits; /* Vecteur a passer au Simplexe pour recuperer les couts reduits */ - double* CoutsMarginauxDesContraintes; /* Vecteur a passer au Simplexe pour recuperer les couts + std::vector PositionDeLaVariable; /* Vecteur a passer au Simplexe pour recuperer la base optimale */ + std::vector ComplementDeLaBase; /* Vecteur a passer au Simplexe pour recuperer la base optimale */ + std::vector CoutsReduits; /* Vecteur a passer au Simplexe pour recuperer les couts reduits */ + std::vector CoutsMarginauxDesContraintes; /* Vecteur a passer au Simplexe pour recuperer les couts marginaux */ } PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE; /* Les correspondances des variables */ typedef struct { - int* NumeroVar_Turbine; /* Turbines */ + std::vector NumeroVar_Turbine; /* Turbines */ - int* NumeroVar_niveauxFinJours; // Niveaux fin jours + std::vector NumeroVar_niveauxFinJours; // Niveaux fin jours int NumeroVar_waste; // Waste - int* NumeroVar_overflow; // Deversements (ecarts journaliers entre niveaux et les 100 % du + std::vector NumeroVar_overflow; // Deversements (ecarts journaliers entre niveaux et les 100 % du // reservoir) - int* NumeroVar_deviations; // Deviations (ecarts journaliers entre turbin?s et cr?dits cibles + std::vector NumeroVar_deviations; // Deviations (ecarts journaliers entre turbin?s et cr?dits cibles // brutes) - int* NumeroVar_violations; // Violations (ecarts journaliers entre niveaux et courbes guides sup + std::vector NumeroVar_violations; // Violations (ecarts journaliers entre niveaux et courbes guides sup // et inf) int NumeroVar_deviationMax; // Deviation max sur le mois int NumeroVar_violationMax; // Violation max sur le mois @@ -122,16 +134,14 @@ typedef struct char LesCoutsOntEteInitialises; /* Vaut OUI ou NON */ int NombreDeProblemes; - int* NbJoursDUnProbleme; - - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU** CorrespondanceDesVariables; + std::vector NbJoursDUnProbleme; - PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE** ProblemeLineaireEtenduPartieFixe; - PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE** ProblemeLineaireEtenduPartieVariable; + std::vector CorrespondanceDesVariables; - void** ProblemeSpx; /* Il y en a 1 par reservoir. Un probleme couvre 1 mois */ - void* Probleme; /* Le probleme en cours passe au simplexe */ + std::vector ProblemeLineaireEtenduPartieFixe; + std::vector ProblemeLineaireEtenduPartieVariable; + std::vector ProblemeSpx; /* Il y en a 1 par reservoir. Un probleme couvre 1 mois */ } PROBLEME_HYDRAULIQUE_ETENDU; namespace Antares::Constants diff --git a/src/solver/hydro/daily2/h2o2_j_fonctions.h b/src/solver/hydro/daily2/h2o2_j_fonctions.h index ea30a56b5f..a96934ca41 100644 --- a/src/solver/hydro/daily2/h2o2_j_fonctions.h +++ b/src/solver/hydro/daily2/h2o2_j_fonctions.h @@ -28,26 +28,26 @@ #ifndef __SOLVER_H2O2_J_FONCTIONS__ #define __SOLVER_H2O2_J_FONCTIONS__ -DONNEES_MENSUELLES_ETENDUES* H2O2_J_Instanciation(); -void H2O2_J_OptimiserUnMois(DONNEES_MENSUELLES_ETENDUES*); -void H2O2_J_Free(DONNEES_MENSUELLES_ETENDUES*); +DONNEES_MENSUELLES_ETENDUES H2O2_J_Instanciation(); +void H2O2_J_OptimiserUnMois(DONNEES_MENSUELLES_ETENDUES&); +void H2O2_J_Free(DONNEES_MENSUELLES_ETENDUES&); void H2O2_J_ConstruireLesContraintes(int, - int*, - char*, - int*, - double*, - int*, - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU*); + std::vector&, + std::vector&, + std::vector&, + std::vector&, + std::vector&, + CORRESPONDANCE_DES_VARIABLES_PB_ETENDU&); void H2O2_j_ConstruireLesVariables(int, - DONNEES_MENSUELLES_ETENDUES*, - double*, - double*, - int*, - double**, - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU*); + DONNEES_MENSUELLES_ETENDUES&, + std::vector&, + std::vector&, + std::vector&, + std::vector&, + CORRESPONDANCE_DES_VARIABLES_PB_ETENDU&); void H2O2_J_apply_costs(const Hydro_problem_costs&, DONNEES_MENSUELLES_ETENDUES&); -void H2O2_J_InitialiserLesBornesdesVariables(DONNEES_MENSUELLES_ETENDUES*, int); -void H2O2_J_InitialiserLeSecondMembre(DONNEES_MENSUELLES_ETENDUES*, int); -void H2O2_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES_ETENDUES*, int); +void H2O2_J_InitialiserLesBornesdesVariables(DONNEES_MENSUELLES_ETENDUES&, int); +void H2O2_J_InitialiserLeSecondMembre(DONNEES_MENSUELLES_ETENDUES&, int); +void H2O2_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES_ETENDUES&, int); #endif /* __SOLVER_H2O2_J_FONCTIONS__ */ diff --git a/src/solver/hydro/daily2/h2o2_j_free.cpp b/src/solver/hydro/daily2/h2o2_j_free.cpp index 14ce65539c..39fd211fd0 100644 --- a/src/solver/hydro/daily2/h2o2_j_free.cpp +++ b/src/solver/hydro/daily2/h2o2_j_free.cpp @@ -40,80 +40,17 @@ extern "C" #include "h2o2_j_donnees_mensuelles.h" #include "h2o2_j_fonctions.h" -void H2O2_J_Free(DONNEES_MENSUELLES_ETENDUES* DonneesMensuelles) +void H2O2_J_Free(DONNEES_MENSUELLES_ETENDUES& DonneesMensuelles) { - int i; - int NombreDeProblemes; - PROBLEME_SPX* ProbSpx; + auto& ProblemeHydrauliqueEtendu = DonneesMensuelles.ProblemeHydrauliqueEtendu; + int NombreDeProblemes = ProblemeHydrauliqueEtendu.NombreDeProblemes; - PROBLEME_HYDRAULIQUE_ETENDU* ProblemeHydrauliqueEtendu; - - ProblemeHydrauliqueEtendu = DonneesMensuelles->ProblemeHydrauliqueEtendu; - NombreDeProblemes = ProblemeHydrauliqueEtendu->NombreDeProblemes; - - for (i = 0; i < NombreDeProblemes; i++) + for (int i = 0; i < NombreDeProblemes; i++) { - free(ProblemeHydrauliqueEtendu->CorrespondanceDesVariables[i]->NumeroVar_Turbine); - free(ProblemeHydrauliqueEtendu->CorrespondanceDesVariables[i]->NumeroVar_niveauxFinJours); - free(ProblemeHydrauliqueEtendu->CorrespondanceDesVariables[i]->NumeroVar_overflow); - free(ProblemeHydrauliqueEtendu->CorrespondanceDesVariables[i]->NumeroVar_deviations); - free(ProblemeHydrauliqueEtendu->CorrespondanceDesVariables[i]->NumeroVar_violations); - free(ProblemeHydrauliqueEtendu->CorrespondanceDesVariables[i]); - - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[i]->CoutLineaire); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[i]->TypeDeVariable); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[i]->Sens); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[i]->IndicesDebutDeLigne); - free((ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[i]) - ->NombreDeTermesDesLignes); - free((ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[i]) - ->CoefficientsDeLaMatriceDesContraintes); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[i]->IndicesColonnes); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[i]); - - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]->Xmin); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]->Xmax); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]->SecondMembre); - free((ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]) - ->AdresseOuPlacerLaValeurDesVariablesOptimisees); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]->X); - free((ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]) - ->PositionDeLaVariable); - free( - ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]->ComplementDeLaBase); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]->CoutsReduits); - free((ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]) - ->CoutsMarginauxDesContraintes); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[i]); - - ProbSpx = (PROBLEME_SPX*)ProblemeHydrauliqueEtendu->ProblemeSpx[i]; - if (ProbSpx != NULL) - { + auto ProbSpx = ProblemeHydrauliqueEtendu.ProblemeSpx[i]; + if (ProbSpx) SPX_LibererProbleme(ProbSpx); - } } - free(ProblemeHydrauliqueEtendu->NbJoursDUnProbleme); - free(ProblemeHydrauliqueEtendu->CorrespondanceDesVariables); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe); - free(ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable); - free(ProblemeHydrauliqueEtendu->ProblemeSpx); - free(ProblemeHydrauliqueEtendu->Probleme); - free(ProblemeHydrauliqueEtendu); - - free(DonneesMensuelles->TurbineMax); - free(DonneesMensuelles->TurbineMin); - free(DonneesMensuelles->TurbineCible); - free(DonneesMensuelles->Turbine); - - free(DonneesMensuelles->niveauBas); - free(DonneesMensuelles->niveauxFinJours); - free(DonneesMensuelles->apports); - free(DonneesMensuelles->overflows); - free(DonneesMensuelles->deviations); - free(DonneesMensuelles->violations); - - free(DonneesMensuelles); - return; } diff --git a/src/solver/hydro/daily2/h2o2_j_initialiser_les_bornes_des_variables.cpp b/src/solver/hydro/daily2/h2o2_j_initialiser_les_bornes_des_variables.cpp index cf4fe744a9..1419d54a2a 100644 --- a/src/solver/hydro/daily2/h2o2_j_initialiser_les_bornes_des_variables.cpp +++ b/src/solver/hydro/daily2/h2o2_j_initialiser_les_bornes_des_variables.cpp @@ -27,40 +27,28 @@ #include "h2o2_j_donnees_mensuelles.h" -void H2O2_J_InitialiserLesBornesdesVariables(DONNEES_MENSUELLES_ETENDUES* DonneesMensuelles, +void H2O2_J_InitialiserLesBornesdesVariables(DONNEES_MENSUELLES_ETENDUES& DonneesMensuelles, int NumeroDeProbleme) { - int Pdt; - int NbPdt; - int Var; - double* Xmax; - double* Xmin; + const auto& TurbineMax = DonneesMensuelles.TurbineMax; + const auto& TurbineMin = DonneesMensuelles.TurbineMin; - int* NumeroVar_Turbine; + auto& ProblemeHydrauliqueEtendu = DonneesMensuelles.ProblemeHydrauliqueEtendu; - double* TurbineMax = DonneesMensuelles->TurbineMax; - const double* TurbineMin = DonneesMensuelles->TurbineMin; + int NbPdt = ProblemeHydrauliqueEtendu.NbJoursDUnProbleme[NumeroDeProbleme]; - PROBLEME_HYDRAULIQUE_ETENDU* ProblemeHydrauliqueEtendu; - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU* CorrespondanceDesVariables; - PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE* ProblemeLineaireEtenduPartieVariable; + auto& CorrespondanceDesVariables + = ProblemeHydrauliqueEtendu.CorrespondanceDesVariables[NumeroDeProbleme]; + auto& ProblemeLineaireEtenduPartieVariable + = ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieVariable[NumeroDeProbleme]; - ProblemeHydrauliqueEtendu = DonneesMensuelles->ProblemeHydrauliqueEtendu; + auto& NumeroVar_Turbine = CorrespondanceDesVariables.NumeroVar_Turbine; - NbPdt = ProblemeHydrauliqueEtendu->NbJoursDUnProbleme[NumeroDeProbleme]; - - CorrespondanceDesVariables - = ProblemeHydrauliqueEtendu->CorrespondanceDesVariables[NumeroDeProbleme]; - ProblemeLineaireEtenduPartieVariable - = ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[NumeroDeProbleme]; - - NumeroVar_Turbine = CorrespondanceDesVariables->NumeroVar_Turbine; - - Xmax = ProblemeLineaireEtenduPartieVariable->Xmax; - Xmin = ProblemeLineaireEtenduPartieVariable->Xmin; - for (Pdt = 0; Pdt < NbPdt; Pdt++) + auto& Xmax = ProblemeLineaireEtenduPartieVariable.Xmax; + auto& Xmin = ProblemeLineaireEtenduPartieVariable.Xmin; + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - Var = NumeroVar_Turbine[Pdt]; + int Var = NumeroVar_Turbine[Pdt]; Xmax[Var] = TurbineMax[Pdt]; Xmin[Var] = TurbineMin[Pdt]; } diff --git a/src/solver/hydro/daily2/h2o2_j_initialiser_les_second_membre.cpp b/src/solver/hydro/daily2/h2o2_j_initialiser_les_second_membre.cpp index 0a6f947f23..982136eb45 100644 --- a/src/solver/hydro/daily2/h2o2_j_initialiser_les_second_membre.cpp +++ b/src/solver/hydro/daily2/h2o2_j_initialiser_les_second_membre.cpp @@ -27,61 +27,55 @@ #include "h2o2_j_donnees_mensuelles.h" -void H2O2_J_InitialiserLeSecondMembre(DONNEES_MENSUELLES_ETENDUES* DonneesMensuelles, +void H2O2_J_InitialiserLeSecondMembre(DONNEES_MENSUELLES_ETENDUES& DonneesMensuelles, int NumeroDeProbleme) { - PROBLEME_HYDRAULIQUE_ETENDU* ProblemeHydrauliqueEtendu; - PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE* ProblemeLineairePartieVariable; - double* SecondMembre; + auto& ProblemeHydrauliqueEtendu = DonneesMensuelles.ProblemeHydrauliqueEtendu; - ProblemeHydrauliqueEtendu = DonneesMensuelles->ProblemeHydrauliqueEtendu; - ProblemeLineairePartieVariable - = ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[NumeroDeProbleme]; - SecondMembre = ProblemeLineairePartieVariable->SecondMembre; + auto& ProblemeLineairePartieVariable + = ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieVariable[NumeroDeProbleme]; + auto& SecondMembre = ProblemeLineairePartieVariable.SecondMembre; - int NbPdt, Pdt, Cnt; + int NbPdt = ProblemeHydrauliqueEtendu.NbJoursDUnProbleme[NumeroDeProbleme]; + int Cnt = 0; - NbPdt = ProblemeHydrauliqueEtendu->NbJoursDUnProbleme[NumeroDeProbleme]; - - Cnt = 0; - - SecondMembre[Cnt] = DonneesMensuelles->NiveauInitialDuMois + DonneesMensuelles->apports[0]; + SecondMembre[Cnt] = DonneesMensuelles.NiveauInitialDuMois + DonneesMensuelles.apports[0]; Cnt++; - for (Pdt = 1; Pdt < NbPdt; Pdt++) + for (int Pdt = 1; Pdt < NbPdt; Pdt++) { - SecondMembre[Cnt] = DonneesMensuelles->apports[Pdt]; + SecondMembre[Cnt] = DonneesMensuelles.apports[Pdt]; Cnt++; } - SecondMembre[Cnt] = DonneesMensuelles->TurbineDuMois; + SecondMembre[Cnt] = DonneesMensuelles.TurbineDuMois; Cnt++; - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - SecondMembre[Cnt] = DonneesMensuelles->TurbineCible[Pdt]; + SecondMembre[Cnt] = DonneesMensuelles.TurbineCible[Pdt]; Cnt++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - SecondMembre[Cnt] = DonneesMensuelles->TurbineCible[Pdt]; + SecondMembre[Cnt] = DonneesMensuelles.TurbineCible[Pdt]; Cnt++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { SecondMembre[Cnt] = 0.; Cnt++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { - SecondMembre[Cnt] = DonneesMensuelles->niveauBas[Pdt]; + SecondMembre[Cnt] = DonneesMensuelles.niveauBas[Pdt]; Cnt++; } - for (Pdt = 0; Pdt < NbPdt; Pdt++) + for (int Pdt = 0; Pdt < NbPdt; Pdt++) { SecondMembre[Cnt] = 0.; Cnt++; diff --git a/src/solver/hydro/daily2/h2o2_j_instanciation.cpp b/src/solver/hydro/daily2/h2o2_j_instanciation.cpp index 6dc6300c18..89b5e22119 100644 --- a/src/solver/hydro/daily2/h2o2_j_instanciation.cpp +++ b/src/solver/hydro/daily2/h2o2_j_instanciation.cpp @@ -28,174 +28,64 @@ #include "h2o2_j_donnees_mensuelles.h" #include "h2o2_j_fonctions.h" -DONNEES_MENSUELLES_ETENDUES* H2O2_J_Instanciation() +DONNEES_MENSUELLES_ETENDUES H2O2_J_Instanciation() { - int i; - int* NbJoursDUnProbleme; - int NombreDeProblemes; - int NbPdt; - int j; - int NombreDeVariables; - int NombreDeContraintes; - int NombreDeTermesAlloues; - DONNEES_MENSUELLES_ETENDUES* DonneesMensuellesEtendues; - PROBLEME_HYDRAULIQUE_ETENDU* ProblemeHydrauliqueEtendu; - - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU** CorrespondanceDesVariables; - PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE** ProblemeLineaireEtenduPartieFixe; - PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE** ProblemeLineaireEtenduPartieVariable; - CORRESPONDANCE_DES_VARIABLES_PB_ETENDU* CorrVar; - PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE* PlFixe; - PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE* PlVariable; - - DonneesMensuellesEtendues - = (DONNEES_MENSUELLES_ETENDUES*)malloc(sizeof(DONNEES_MENSUELLES_ETENDUES)); - if (DonneesMensuellesEtendues == NULL) - return (NULL); - - DonneesMensuellesEtendues->ProblemeHydrauliqueEtendu - = (PROBLEME_HYDRAULIQUE_ETENDU*)malloc(sizeof(PROBLEME_HYDRAULIQUE_ETENDU)); - if (DonneesMensuellesEtendues->ProblemeHydrauliqueEtendu == NULL) - return (NULL); - - ProblemeHydrauliqueEtendu = DonneesMensuellesEtendues->ProblemeHydrauliqueEtendu; - - ProblemeHydrauliqueEtendu->NombreDeProblemes = 4; - - ProblemeHydrauliqueEtendu->NbJoursDUnProbleme - = (int*)malloc(ProblemeHydrauliqueEtendu->NombreDeProblemes * sizeof(int)); - if (ProblemeHydrauliqueEtendu->NbJoursDUnProbleme == NULL) - return (0); - - NbJoursDUnProbleme = ProblemeHydrauliqueEtendu->NbJoursDUnProbleme; + DONNEES_MENSUELLES_ETENDUES DonneesMensuellesEtendues; + + auto& ProblemeHydrauliqueEtendu = DonneesMensuellesEtendues.ProblemeHydrauliqueEtendu; + + ProblemeHydrauliqueEtendu.NombreDeProblemes = 4; + + auto& NbJoursDUnProbleme = ProblemeHydrauliqueEtendu.NbJoursDUnProbleme; + NbJoursDUnProbleme.assign(ProblemeHydrauliqueEtendu.NombreDeProblemes, 0); + NbJoursDUnProbleme[0] = 28; NbJoursDUnProbleme[1] = 29; NbJoursDUnProbleme[2] = 30; NbJoursDUnProbleme[3] = 31; - DonneesMensuellesEtendues->TurbineMax = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->TurbineMax == NULL) - return (NULL); - - DonneesMensuellesEtendues->TurbineMin = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->TurbineMin == NULL) - return (NULL); - - DonneesMensuellesEtendues->TurbineCible - = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->TurbineCible == NULL) - return (NULL); - - DonneesMensuellesEtendues->niveauBas = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->niveauBas == NULL) - return (NULL); - - DonneesMensuellesEtendues->apports = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->apports == NULL) - return (NULL); - - DonneesMensuellesEtendues->Turbine = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->Turbine == NULL) - return (NULL); - - DonneesMensuellesEtendues->niveauxFinJours - = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->niveauxFinJours == NULL) - return (NULL); - - DonneesMensuellesEtendues->overflows = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->overflows == NULL) - return (NULL); - - DonneesMensuellesEtendues->deviations = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->deviations == NULL) - return (NULL); - - DonneesMensuellesEtendues->violations = (double*)malloc(NbJoursDUnProbleme[3] * sizeof(double)); - if (DonneesMensuellesEtendues->violations == NULL) - return (NULL); - - NombreDeProblemes = ProblemeHydrauliqueEtendu->NombreDeProblemes; - - ProblemeHydrauliqueEtendu->CorrespondanceDesVariables - = (CORRESPONDANCE_DES_VARIABLES_PB_ETENDU**)malloc( - NombreDeProblemes * sizeof(CORRESPONDANCE_DES_VARIABLES_PB_ETENDU)); - if (ProblemeHydrauliqueEtendu->CorrespondanceDesVariables == NULL) - return (0); - - ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe - = (PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE**)malloc( - NombreDeProblemes * sizeof(PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE)); - if (ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe == NULL) - return (0); - - ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable - = (PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE**)malloc( - NombreDeProblemes * sizeof(PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE)); - if (ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable == NULL) - return (0); - - ProblemeHydrauliqueEtendu->ProblemeSpx = (void**)malloc(NombreDeProblemes * sizeof(void*)); - if (ProblemeHydrauliqueEtendu->ProblemeSpx == NULL) - return (0); - - for (i = 0; i < NombreDeProblemes; i++) - ProblemeHydrauliqueEtendu->ProblemeSpx[i] = NULL; - - ProblemeHydrauliqueEtendu->Probleme = NULL; - - CorrespondanceDesVariables = ProblemeHydrauliqueEtendu->CorrespondanceDesVariables; - ProblemeLineaireEtenduPartieFixe = ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe; - ProblemeLineaireEtenduPartieVariable - = ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable; - - for (i = 0; i < NombreDeProblemes; i++) - { - CorrespondanceDesVariables[i] = (CORRESPONDANCE_DES_VARIABLES_PB_ETENDU*)malloc( - sizeof(CORRESPONDANCE_DES_VARIABLES_PB_ETENDU)); - if (CorrespondanceDesVariables[i] == NULL) - return (0); - - ProblemeLineaireEtenduPartieFixe[i] = (PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE*)malloc( - sizeof(PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE)); - if (ProblemeLineaireEtenduPartieFixe[i] == NULL) - return (0); - - ProblemeLineaireEtenduPartieVariable[i] = (PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE*)malloc( - sizeof(PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE)); - if (ProblemeLineaireEtenduPartieVariable[i] == NULL) - return (0); - } + DonneesMensuellesEtendues.TurbineMax.assign(NbJoursDUnProbleme[3], 0.); + DonneesMensuellesEtendues.TurbineMin.assign(NbJoursDUnProbleme[3], 0.); + DonneesMensuellesEtendues.TurbineCible.assign(NbJoursDUnProbleme[3], 0.); - for (i = 0; i < NombreDeProblemes; i++) - { - NbPdt = NbJoursDUnProbleme[i]; + DonneesMensuellesEtendues.niveauBas.assign(NbJoursDUnProbleme[3], 0.); + DonneesMensuellesEtendues.apports.assign(NbJoursDUnProbleme[3], 0.); - CorrVar = CorrespondanceDesVariables[i]; + DonneesMensuellesEtendues.Turbine.assign(NbJoursDUnProbleme[3], 0.); + DonneesMensuellesEtendues.niveauxFinJours.assign(NbJoursDUnProbleme[3], 0.); + DonneesMensuellesEtendues.overflows.assign(NbJoursDUnProbleme[3], 0.); + DonneesMensuellesEtendues.deviations.assign(NbJoursDUnProbleme[3], 0.); + DonneesMensuellesEtendues.violations.assign(NbJoursDUnProbleme[3], 0.); - CorrVar->NumeroVar_Turbine = (int*)malloc(NbPdt * sizeof(int)); - if (CorrVar->NumeroVar_Turbine == NULL) - return (0); + int NombreDeProblemes = ProblemeHydrauliqueEtendu.NombreDeProblemes; - CorrVar->NumeroVar_niveauxFinJours = (int*)malloc(NbPdt * sizeof(int)); - if (CorrVar->NumeroVar_niveauxFinJours == NULL) - return (0); + ProblemeHydrauliqueEtendu.CorrespondanceDesVariables.resize(NombreDeProblemes); + ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieFixe.resize(NombreDeProblemes); + ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieVariable.resize(NombreDeProblemes); - CorrVar->NumeroVar_overflow = (int*)malloc(NbPdt * sizeof(int)); - if (CorrVar->NumeroVar_overflow == NULL) - return (0); + ProblemeHydrauliqueEtendu.ProblemeSpx.assign(NombreDeProblemes, nullptr); - CorrVar->NumeroVar_deviations = (int*)malloc(NbPdt * sizeof(int)); - if (CorrVar->NumeroVar_deviations == NULL) - return (0); + auto& CorrespondanceDesVariables = ProblemeHydrauliqueEtendu.CorrespondanceDesVariables; + auto& ProblemeLineaireEtenduPartieFixe + = ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieFixe; + auto& ProblemeLineaireEtenduPartieVariable + = ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieVariable; + + for (int i = 0; i < NombreDeProblemes; i++) + { + int NbPdt = NbJoursDUnProbleme[i]; - CorrVar->NumeroVar_violations = (int*)malloc(NbPdt * sizeof(int)); - if (CorrVar->NumeroVar_violations == NULL) - return (0); + auto& CorrVar = CorrespondanceDesVariables[i]; - PlFixe = ProblemeLineaireEtenduPartieFixe[i]; + CorrVar.NumeroVar_Turbine.assign(NbPdt, 0); + CorrVar.NumeroVar_niveauxFinJours.assign(NbPdt, 0); + CorrVar.NumeroVar_overflow.assign(NbPdt, 0); + CorrVar.NumeroVar_deviations.assign(NbPdt, 0); + CorrVar.NumeroVar_violations.assign(NbPdt, 0); - NombreDeVariables = 0; + auto& PlFixe = ProblemeLineaireEtenduPartieFixe[i]; + + int NombreDeVariables = 0; NombreDeVariables += NbPdt; NombreDeVariables += NbPdt; @@ -207,16 +97,12 @@ DONNEES_MENSUELLES_ETENDUES* H2O2_J_Instanciation() NombreDeVariables += 1; NombreDeVariables += 1; - PlFixe->NombreDeVariables = NombreDeVariables; - PlFixe->CoutLineaire = (double*)malloc(NombreDeVariables * sizeof(double)); - if (PlFixe->CoutLineaire == NULL) - return (0); + PlFixe.NombreDeVariables = NombreDeVariables; + PlFixe.CoutLineaire.assign(NombreDeVariables, 0); - PlFixe->TypeDeVariable = (int*)malloc(NombreDeVariables * sizeof(int)); - if (PlFixe->TypeDeVariable == NULL) - return (0); + PlFixe.TypeDeVariable.assign(NombreDeVariables, 0); - NombreDeContraintes = 0; + int NombreDeContraintes = 0; NombreDeContraintes += NbPdt; NombreDeContraintes += 1; @@ -226,20 +112,13 @@ DONNEES_MENSUELLES_ETENDUES* H2O2_J_Instanciation() NombreDeContraintes += NbPdt; NombreDeContraintes += NbPdt; - PlFixe->NombreDeContraintes = NombreDeContraintes; - PlFixe->Sens = (char*)malloc(NombreDeContraintes * sizeof(char)); - if (PlFixe->Sens == NULL) - return (0); - - PlFixe->IndicesDebutDeLigne = (int*)malloc(NombreDeContraintes * sizeof(int)); - if (PlFixe->IndicesDebutDeLigne == NULL) - return (0); + PlFixe.NombreDeContraintes = NombreDeContraintes; + PlFixe.Sens.assign(NombreDeContraintes, 0); - PlFixe->NombreDeTermesDesLignes = (int*)malloc(NombreDeContraintes * sizeof(int)); - if (PlFixe->NombreDeTermesDesLignes == NULL) - return (0); + PlFixe.IndicesDebutDeLigne.assign(NombreDeContraintes, 0.); + PlFixe.NombreDeTermesDesLignes.assign(NombreDeContraintes, 0.); - NombreDeTermesAlloues = 0; + int NombreDeTermesAlloues = 0; NombreDeTermesAlloues += 3; NombreDeTermesAlloues += 4 * (NbPdt - 1); NombreDeTermesAlloues += 1; @@ -250,79 +129,47 @@ DONNEES_MENSUELLES_ETENDUES* H2O2_J_Instanciation() NombreDeTermesAlloues += 2 * NbPdt; NombreDeTermesAlloues += 2 * NbPdt; - PlFixe->NombreDeTermesAlloues = NombreDeTermesAlloues; - PlFixe->CoefficientsDeLaMatriceDesContraintes - = (double*)malloc(NombreDeTermesAlloues * sizeof(double)); - if (PlFixe->CoefficientsDeLaMatriceDesContraintes == NULL) - return (0); - - PlFixe->IndicesColonnes = (int*)malloc(NombreDeTermesAlloues * sizeof(int)); - if (PlFixe->IndicesColonnes == NULL) - return (0); - - PlVariable = ProblemeLineaireEtenduPartieVariable[i]; - PlVariable->Xmin = (double*)malloc(NombreDeVariables * sizeof(double)); - if (PlVariable->Xmin == NULL) - return (0); - - PlVariable->Xmax = (double*)malloc(NombreDeVariables * sizeof(double)); - if (PlVariable->Xmax == NULL) - return (0); - - PlVariable->SecondMembre = (double*)malloc(NombreDeContraintes * sizeof(double)); - if (PlVariable->SecondMembre == NULL) - return (0); - - PlVariable->AdresseOuPlacerLaValeurDesVariablesOptimisees - = (double**)malloc(NombreDeVariables * sizeof(double*)); - if (PlVariable->AdresseOuPlacerLaValeurDesVariablesOptimisees == NULL) - return (0); - - PlVariable->X = (double*)malloc(NombreDeVariables * sizeof(double)); - if (PlVariable->X == NULL) - return (0); - - for (j = 0; j < NombreDeVariables; j++) - PlVariable->AdresseOuPlacerLaValeurDesVariablesOptimisees[j] = NULL; - - PlVariable->PositionDeLaVariable = (int*)malloc(NombreDeVariables * sizeof(int)); - if (PlVariable->PositionDeLaVariable == NULL) - return (0); - - PlVariable->ComplementDeLaBase = (int*)malloc(NombreDeContraintes * sizeof(int)); - if (PlVariable->ComplementDeLaBase == NULL) - return (0); - - PlVariable->CoutsReduits = (double*)malloc(NombreDeVariables * sizeof(double)); - if (PlVariable->CoutsReduits == NULL) - return (0); - - PlVariable->CoutsMarginauxDesContraintes - = (double*)malloc(NombreDeContraintes * sizeof(double)); - if (PlVariable->CoutsMarginauxDesContraintes == NULL) - return (0); + PlFixe.NombreDeTermesAlloues = NombreDeTermesAlloues; + PlFixe.CoefficientsDeLaMatriceDesContraintes.assign(NombreDeTermesAlloues, 0.); + + PlFixe.IndicesColonnes.assign(NombreDeTermesAlloues, 0); + + auto& PlVariable = ProblemeLineaireEtenduPartieVariable[i]; + + PlVariable.X.assign(NombreDeVariables, 0.); + PlVariable.Xmin.assign(NombreDeVariables, 0.); + PlVariable.Xmax.assign(NombreDeVariables, 0.); + PlVariable.SecondMembre.assign(NombreDeContraintes, 0.); + + PlVariable.AdresseOuPlacerLaValeurDesVariablesOptimisees.assign(NombreDeVariables, nullptr); + + PlVariable.PositionDeLaVariable.assign(NombreDeVariables, 0); + PlVariable.ComplementDeLaBase.assign(NombreDeContraintes, 0); + + PlVariable.CoutsReduits.assign(NombreDeVariables, 0.); + PlVariable.CoutsMarginauxDesContraintes.assign(NombreDeContraintes, 0.); } - for (i = 0; i < NombreDeProblemes; i++) + for (int i = 0; i < NombreDeProblemes; i++) { H2O2_j_ConstruireLesVariables( NbJoursDUnProbleme[i], DonneesMensuellesEtendues, - ProblemeLineaireEtenduPartieVariable[i]->Xmin, - ProblemeLineaireEtenduPartieVariable[i]->Xmax, - ProblemeLineaireEtenduPartieFixe[i]->TypeDeVariable, - ProblemeLineaireEtenduPartieVariable[i]->AdresseOuPlacerLaValeurDesVariablesOptimisees, + ProblemeLineaireEtenduPartieVariable[i].Xmin, + ProblemeLineaireEtenduPartieVariable[i].Xmax, + ProblemeLineaireEtenduPartieFixe[i].TypeDeVariable, + ProblemeLineaireEtenduPartieVariable[i].AdresseOuPlacerLaValeurDesVariablesOptimisees, CorrespondanceDesVariables[i]); H2O2_J_ConstruireLesContraintes( NbJoursDUnProbleme[i], - ProblemeLineaireEtenduPartieFixe[i]->IndicesDebutDeLigne, - ProblemeLineaireEtenduPartieFixe[i]->Sens, - ProblemeLineaireEtenduPartieFixe[i]->NombreDeTermesDesLignes, - ProblemeLineaireEtenduPartieFixe[i]->CoefficientsDeLaMatriceDesContraintes, - ProblemeLineaireEtenduPartieFixe[i]->IndicesColonnes, + ProblemeLineaireEtenduPartieFixe[i].IndicesDebutDeLigne, + ProblemeLineaireEtenduPartieFixe[i].Sens, + ProblemeLineaireEtenduPartieFixe[i].NombreDeTermesDesLignes, + ProblemeLineaireEtenduPartieFixe[i].CoefficientsDeLaMatriceDesContraintes, + ProblemeLineaireEtenduPartieFixe[i].IndicesColonnes, CorrespondanceDesVariables[i]); } - return (DonneesMensuellesEtendues); + return DonneesMensuellesEtendues; } diff --git a/src/solver/hydro/daily2/h2o2_j_optimiser_un_mois.cpp b/src/solver/hydro/daily2/h2o2_j_optimiser_un_mois.cpp index e41a0ff52f..c791b2d8ae 100644 --- a/src/solver/hydro/daily2/h2o2_j_optimiser_un_mois.cpp +++ b/src/solver/hydro/daily2/h2o2_j_optimiser_un_mois.cpp @@ -28,17 +28,15 @@ #include "h2o2_j_donnees_mensuelles.h" #include "h2o2_j_fonctions.h" -void H2O2_J_OptimiserUnMois(DONNEES_MENSUELLES_ETENDUES* DonneesMensuelles) +void H2O2_J_OptimiserUnMois(DONNEES_MENSUELLES_ETENDUES& DonneesMensuelles) { - PROBLEME_HYDRAULIQUE_ETENDU* ProblemeHydrauliqueEtendu; - - ProblemeHydrauliqueEtendu = DonneesMensuelles->ProblemeHydrauliqueEtendu; + auto& ProblemeHydrauliqueEtendu = DonneesMensuelles.ProblemeHydrauliqueEtendu; int NumeroDeProbleme = -1; - for (int i = 0; i < ProblemeHydrauliqueEtendu->NombreDeProblemes; i++) + for (int i = 0; i < ProblemeHydrauliqueEtendu.NombreDeProblemes; i++) { - if (DonneesMensuelles->NombreDeJoursDuMois - == ProblemeHydrauliqueEtendu->NbJoursDUnProbleme[i]) + if (DonneesMensuelles.NombreDeJoursDuMois + == ProblemeHydrauliqueEtendu.NbJoursDUnProbleme[i]) { NumeroDeProbleme = i; break; @@ -47,16 +45,14 @@ void H2O2_J_OptimiserUnMois(DONNEES_MENSUELLES_ETENDUES* DonneesMensuelles) if (NumeroDeProbleme < 0) { - DonneesMensuelles->ResultatsValides = EMERGENCY_SHUT_DOWN; + DonneesMensuelles.ResultatsValides = EMERGENCY_SHUT_DOWN; return; } - DonneesMensuelles->ResultatsValides = NON; + DonneesMensuelles.ResultatsValides = NON; H2O2_J_InitialiserLeSecondMembre(DonneesMensuelles, NumeroDeProbleme); - H2O2_J_InitialiserLesBornesdesVariables(DonneesMensuelles, NumeroDeProbleme); - H2O2_J_ResoudreLeProblemeLineaire(DonneesMensuelles, NumeroDeProbleme); return; diff --git a/src/solver/hydro/daily2/h2o2_j_resoudre_le_probleme_lineaire.cpp b/src/solver/hydro/daily2/h2o2_j_resoudre_le_probleme_lineaire.cpp index bd4ab20a2a..75a5741d8d 100644 --- a/src/solver/hydro/daily2/h2o2_j_resoudre_le_probleme_lineaire.cpp +++ b/src/solver/hydro/daily2/h2o2_j_resoudre_le_probleme_lineaire.cpp @@ -25,18 +25,6 @@ ** SPDX-License-Identifier: licenceRef-GPL3_WITH_RTE-Exceptions */ -#ifdef __CPLUSPLUS -extern "C" -{ -#endif - -#include "spx_definition_arguments.h" -#include "spx_fonctions.h" - -#ifdef __CPLUSPLUS -} -#endif - #include "h2o2_j_donnees_mensuelles.h" #include "h2o2_j_fonctions.h" @@ -46,46 +34,24 @@ extern "C" #define SNPRINTF snprintf #endif -void H2O2_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES_ETENDUES* DonneesMensuelles, +void H2O2_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES_ETENDUES& DonneesMensuelles, int NumeroDeProbleme) { - int Var; - double* pt; - char PremierPassage; - - PROBLEME_HYDRAULIQUE_ETENDU* ProblemeHydrauliqueEtendu; - PROBLEME_LINEAIRE_ETENDU_PARTIE_VARIABLE* ProblemeLineaireEtenduPartieVariable; - PROBLEME_LINEAIRE_ETENDU_PARTIE_FIXE* ProblemeLineaireEtenduPartieFixe; - - PROBLEME_SIMPLEXE* Probleme; - PROBLEME_SPX* ProbSpx; + auto& ProblemeHydrauliqueEtendu = DonneesMensuelles.ProblemeHydrauliqueEtendu; - PremierPassage = OUI; + auto& ProblemeLineaireEtenduPartieVariable + = ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieVariable[NumeroDeProbleme]; + auto& ProblemeLineaireEtenduPartieFixe + = ProblemeHydrauliqueEtendu.ProblemeLineaireEtenduPartieFixe[NumeroDeProbleme]; - ProblemeHydrauliqueEtendu = DonneesMensuelles->ProblemeHydrauliqueEtendu; + PROBLEME_SPX* ProbSpx = ProblemeHydrauliqueEtendu.ProblemeSpx[NumeroDeProbleme]; + auto Probleme = std::make_unique(); - ProblemeLineaireEtenduPartieVariable - = ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieVariable[NumeroDeProbleme]; - ProblemeLineaireEtenduPartieFixe - = ProblemeHydrauliqueEtendu->ProblemeLineaireEtenduPartieFixe[NumeroDeProbleme]; - - ProbSpx = (PROBLEME_SPX*)ProblemeHydrauliqueEtendu->ProblemeSpx[NumeroDeProbleme]; - - Probleme = (PROBLEME_SIMPLEXE*)ProblemeHydrauliqueEtendu->Probleme; - if (Probleme == NULL) - { - Probleme = (PROBLEME_SIMPLEXE*)malloc(sizeof(PROBLEME_SIMPLEXE)); - if (Probleme == NULL) - { - DonneesMensuelles->ResultatsValides = EMERGENCY_SHUT_DOWN; - return; - } - ProblemeHydrauliqueEtendu->Probleme = (void*)Probleme; - } + bool premierPassage = true; RESOLUTION: - if (ProbSpx == NULL) + if (!ProbSpx) { Probleme->Contexte = SIMPLEXE_SEUL; Probleme->BaseDeDepartFournie = NON_SPX; @@ -97,29 +63,29 @@ void H2O2_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES_ETENDUES* DonneesMensu Probleme->BaseDeDepartFournie = UTILISER_LA_BASE_DU_PROBLEME_SPX; SPX_ModifierLeVecteurSecondMembre(ProbSpx, - ProblemeLineaireEtenduPartieVariable->SecondMembre, - ProblemeLineaireEtenduPartieFixe->Sens, - ProblemeLineaireEtenduPartieFixe->NombreDeContraintes); + ProblemeLineaireEtenduPartieVariable.SecondMembre.data(), + ProblemeLineaireEtenduPartieFixe.Sens.data(), + ProblemeLineaireEtenduPartieFixe.NombreDeContraintes); } Probleme->NombreMaxDIterations = -1; Probleme->DureeMaxDuCalcul = -1.; - Probleme->CoutLineaire = ProblemeLineaireEtenduPartieFixe->CoutLineaire; - Probleme->X = ProblemeLineaireEtenduPartieVariable->X; - Probleme->Xmin = ProblemeLineaireEtenduPartieVariable->Xmin; - Probleme->Xmax = ProblemeLineaireEtenduPartieVariable->Xmax; - Probleme->NombreDeVariables = ProblemeLineaireEtenduPartieFixe->NombreDeVariables; - Probleme->TypeDeVariable = ProblemeLineaireEtenduPartieFixe->TypeDeVariable; - - Probleme->NombreDeContraintes = ProblemeLineaireEtenduPartieFixe->NombreDeContraintes; - Probleme->IndicesDebutDeLigne = ProblemeLineaireEtenduPartieFixe->IndicesDebutDeLigne; - Probleme->NombreDeTermesDesLignes = ProblemeLineaireEtenduPartieFixe->NombreDeTermesDesLignes; - Probleme->IndicesColonnes = ProblemeLineaireEtenduPartieFixe->IndicesColonnes; + Probleme->CoutLineaire = ProblemeLineaireEtenduPartieFixe.CoutLineaire.data(); + Probleme->X = ProblemeLineaireEtenduPartieVariable.X.data(); + Probleme->Xmin = ProblemeLineaireEtenduPartieVariable.Xmin.data(); + Probleme->Xmax = ProblemeLineaireEtenduPartieVariable.Xmax.data(); + Probleme->NombreDeVariables = ProblemeLineaireEtenduPartieFixe.NombreDeVariables; + Probleme->TypeDeVariable = ProblemeLineaireEtenduPartieFixe.TypeDeVariable.data(); + + Probleme->NombreDeContraintes = ProblemeLineaireEtenduPartieFixe.NombreDeContraintes; + Probleme->IndicesDebutDeLigne = ProblemeLineaireEtenduPartieFixe.IndicesDebutDeLigne.data(); + Probleme->NombreDeTermesDesLignes = ProblemeLineaireEtenduPartieFixe.NombreDeTermesDesLignes.data(); + Probleme->IndicesColonnes = ProblemeLineaireEtenduPartieFixe.IndicesColonnes.data(); Probleme->CoefficientsDeLaMatriceDesContraintes - = ProblemeLineaireEtenduPartieFixe->CoefficientsDeLaMatriceDesContraintes; - Probleme->Sens = ProblemeLineaireEtenduPartieFixe->Sens; - Probleme->SecondMembre = ProblemeLineaireEtenduPartieVariable->SecondMembre; + = ProblemeLineaireEtenduPartieFixe.CoefficientsDeLaMatriceDesContraintes.data(); + Probleme->Sens = ProblemeLineaireEtenduPartieFixe.Sens.data(); + Probleme->SecondMembre = ProblemeLineaireEtenduPartieVariable.SecondMembre.data(); Probleme->ChoixDeLAlgorithme = SPX_DUAL; @@ -127,9 +93,9 @@ void H2O2_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES_ETENDUES* DonneesMensu Probleme->FaireDuScaling = OUI_SPX; Probleme->StrategieAntiDegenerescence = AGRESSIF; - Probleme->PositionDeLaVariable = ProblemeLineaireEtenduPartieVariable->PositionDeLaVariable; + Probleme->PositionDeLaVariable = ProblemeLineaireEtenduPartieVariable.PositionDeLaVariable.data(); Probleme->NbVarDeBaseComplementaires = 0; - Probleme->ComplementDeLaBase = ProblemeLineaireEtenduPartieVariable->ComplementDeLaBase; + Probleme->ComplementDeLaBase = ProblemeLineaireEtenduPartieVariable.ComplementDeLaBase.data(); Probleme->LibererMemoireALaFin = NON_SPX; @@ -137,11 +103,11 @@ void H2O2_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES_ETENDUES* DonneesMensu Probleme->CoutMax = 0.0; Probleme->CoutsMarginauxDesContraintes - = ProblemeLineaireEtenduPartieVariable->CoutsMarginauxDesContraintes; - Probleme->CoutsReduits = ProblemeLineaireEtenduPartieVariable->CoutsReduits; + = ProblemeLineaireEtenduPartieVariable.CoutsMarginauxDesContraintes.data(); + Probleme->CoutsReduits = ProblemeLineaireEtenduPartieVariable.CoutsReduits.data(); #ifndef NDEBUG - if (PremierPassage == OUI) + if (premierPassage) Probleme->AffichageDesTraces = NON_SPX; else Probleme->AffichageDesTraces = OUI_SPX; @@ -151,54 +117,50 @@ void H2O2_J_ResoudreLeProblemeLineaire(DONNEES_MENSUELLES_ETENDUES* DonneesMensu Probleme->NombreDeContraintesCoupes = 0; - ProbSpx = SPX_Simplexe(Probleme, ProbSpx); + ProbSpx = SPX_Simplexe(Probleme.get(), ProbSpx); - if (ProbSpx != NULL) - { - ProblemeHydrauliqueEtendu->ProblemeSpx[NumeroDeProbleme] = (void*)ProbSpx; - } + if (ProbSpx) + ProblemeHydrauliqueEtendu.ProblemeSpx[NumeroDeProbleme] = ProbSpx; - ProblemeLineaireEtenduPartieVariable->ExistenceDUneSolution = Probleme->ExistenceDUneSolution; + ProblemeLineaireEtenduPartieVariable.ExistenceDUneSolution = Probleme->ExistenceDUneSolution; - if (ProblemeLineaireEtenduPartieVariable->ExistenceDUneSolution != OUI_SPX - && PremierPassage == OUI && ProbSpx != NULL) + if (ProblemeLineaireEtenduPartieVariable.ExistenceDUneSolution != OUI_SPX + && premierPassage && ProbSpx) { - if (ProblemeLineaireEtenduPartieVariable->ExistenceDUneSolution != SPX_ERREUR_INTERNE) + if (ProblemeLineaireEtenduPartieVariable.ExistenceDUneSolution != SPX_ERREUR_INTERNE) { SPX_LibererProbleme(ProbSpx); ProbSpx = NULL; - PremierPassage = NON; + premierPassage = false; goto RESOLUTION; } else { - DonneesMensuelles->ResultatsValides = EMERGENCY_SHUT_DOWN; + DonneesMensuelles.ResultatsValides = EMERGENCY_SHUT_DOWN; return; } } - if (ProblemeLineaireEtenduPartieVariable->ExistenceDUneSolution == OUI_SPX) + if (ProblemeLineaireEtenduPartieVariable.ExistenceDUneSolution == OUI_SPX) { - DonneesMensuelles->CoutSolution = 0.0; - for (Var = 0; Var < Probleme->NombreDeVariables; Var++) - DonneesMensuelles->CoutSolution += Probleme->CoutLineaire[Var] * Probleme->X[Var]; + DonneesMensuelles.CoutSolution = 0.0; + for (int Var = 0; Var < Probleme->NombreDeVariables; Var++) + DonneesMensuelles.CoutSolution += Probleme->CoutLineaire[Var] * Probleme->X[Var]; - DonneesMensuelles->ResultatsValides = OUI; + DonneesMensuelles.ResultatsValides = OUI; - for (Var = 0; Var < ProblemeLineaireEtenduPartieFixe->NombreDeVariables; Var++) + for (int Var = 0; Var < ProblemeLineaireEtenduPartieFixe.NombreDeVariables; Var++) { - pt = ProblemeLineaireEtenduPartieVariable - ->AdresseOuPlacerLaValeurDesVariablesOptimisees[Var]; - if (pt != NULL) - { - *pt = ProblemeLineaireEtenduPartieVariable->X[Var]; - } + double* pt = ProblemeLineaireEtenduPartieVariable + .AdresseOuPlacerLaValeurDesVariablesOptimisees[Var]; + if (pt) + *pt = ProblemeLineaireEtenduPartieVariable.X[Var]; } } else { - DonneesMensuelles->ResultatsValides = NON; + DonneesMensuelles.ResultatsValides = NON; return; } diff --git a/src/solver/hydro/management/daily.cpp b/src/solver/hydro/management/daily.cpp index abe4f9fab4..d97a0934c6 100644 --- a/src/solver/hydro/management/daily.cpp +++ b/src/solver/hydro/management/daily.cpp @@ -457,7 +457,7 @@ inline void HydroManagement::prepareDailyOptimalGenerations(Solver::Variable::St uint firstDay = calendar_.months[simulationMonth].daysYear.first; uint endDay = firstDay + daysPerMonth; - DONNEES_MENSUELLES_ETENDUES& problem = *H2O2_J_Instanciation(); + DONNEES_MENSUELLES_ETENDUES problem = H2O2_J_Instanciation(); H2O2_J_apply_costs(h2o2_optim_costs, problem); if (debugData) @@ -487,7 +487,7 @@ inline void HydroManagement::prepareDailyOptimalGenerations(Solver::Variable::St dayMonth++; } - H2O2_J_OptimiserUnMois(&problem); + H2O2_J_OptimiserUnMois(problem); switch (problem.ResultatsValides) { @@ -537,7 +537,7 @@ inline void HydroManagement::prepareDailyOptimalGenerations(Solver::Variable::St break; } - H2O2_J_Free(&problem); + H2O2_J_Free(problem); } uint firstDaySimu = parameters_.simulationDays.first; diff --git a/src/solver/hydro/monthly/h2o_m_donnees_optimisation.h b/src/solver/hydro/monthly/h2o_m_donnees_optimisation.h index 0ff290ac78..7395dfa915 100644 --- a/src/solver/hydro/monthly/h2o_m_donnees_optimisation.h +++ b/src/solver/hydro/monthly/h2o_m_donnees_optimisation.h @@ -27,6 +27,18 @@ #ifndef __SOLVER_H2O_M_STRUCTURE_INTERNE__ #define __SOLVER_H2O_M_STRUCTURE_INTERNE__ +#ifdef __CPLUSPLUS +extern "C" +{ +#endif + +#include "spx_definition_arguments.h" +#include "spx_fonctions.h" + +#ifdef __CPLUSPLUS +} +#endif + #include #define LINFINI 1.e+80 @@ -115,8 +127,7 @@ typedef struct PROBLEME_LINEAIRE_PARTIE_FIXE ProblemeLineairePartieFixe; PROBLEME_LINEAIRE_PARTIE_VARIABLE ProblemeLineairePartieVariable; - std::vector ProblemeSpx; /* Il y en a 1 par reservoir */ - void* Probleme; /* Le probleme en cours passe au simplexe */ + std::vector ProblemeSpx; /* Il y en a 1 par reservoir */ double CoutDeLaSolution; double CoutDeLaSolutionBruite; diff --git a/src/solver/hydro/monthly/h2o_m_instanciation.cpp b/src/solver/hydro/monthly/h2o_m_instanciation.cpp index e91df7a7be..f6166a3a94 100644 --- a/src/solver/hydro/monthly/h2o_m_instanciation.cpp +++ b/src/solver/hydro/monthly/h2o_m_instanciation.cpp @@ -51,7 +51,6 @@ DONNEES_ANNUELLES H2O_M_Instanciation(int NombreDeReservoirs) ProblemeHydraulique.NombreDeReservoirs = NombreDeReservoirs; ProblemeHydraulique.ProblemeSpx.assign(NombreDeReservoirs, nullptr); - ProblemeHydraulique.Probleme = nullptr; CORRESPONDANCE_DES_VARIABLES& CorrespondanceDesVariables = ProblemeHydraulique.CorrespondanceDesVariables; diff --git a/src/solver/hydro/monthly/h2o_m_resoudre_le_probleme_lineaire.cpp b/src/solver/hydro/monthly/h2o_m_resoudre_le_probleme_lineaire.cpp index 56a69881ed..8b61cc3ee3 100644 --- a/src/solver/hydro/monthly/h2o_m_resoudre_le_probleme_lineaire.cpp +++ b/src/solver/hydro/monthly/h2o_m_resoudre_le_probleme_lineaire.cpp @@ -25,18 +25,6 @@ ** SPDX-License-Identifier: licenceRef-GPL3_WITH_RTE-Exceptions */ -#ifdef __CPLUSPLUS -extern "C" -{ -#endif - -#include "spx_definition_arguments.h" -#include "spx_fonctions.h" - -#ifdef __CPLUSPLUS -} -#endif - #include "h2o_m_donnees_annuelles.h" #include "h2o_m_fonctions.h" @@ -57,15 +45,9 @@ void H2O_M_ResoudreLeProblemeLineaire(DONNEES_ANNUELLES& DonneesAnnuelles, int N = ProblemeHydraulique.ProblemeLineairePartieFixe; - PROBLEME_SPX* ProbSpx = (PROBLEME_SPX*)ProblemeHydraulique.ProblemeSpx[NumeroDeReservoir]; + PROBLEME_SPX* ProbSpx = ProblemeHydraulique.ProblemeSpx[NumeroDeReservoir]; std::unique_ptr Probleme = std::make_unique(); - if (!Probleme) - { - DonneesAnnuelles.ResultatsValides = EMERGENCY_SHUT_DOWN; - return; - } - bool PremierPassage = true; RESOLUTION: @@ -139,7 +121,7 @@ void H2O_M_ResoudreLeProblemeLineaire(DONNEES_ANNUELLES& DonneesAnnuelles, int N ProbSpx = SPX_Simplexe(Probleme.get(), ProbSpx); if (ProbSpx) - ProblemeHydraulique.ProblemeSpx[NumeroDeReservoir] = (void*)ProbSpx; + ProblemeHydraulique.ProblemeSpx[NumeroDeReservoir] = ProbSpx; ProblemeLineairePartieVariable.ExistenceDUneSolution = Probleme->ExistenceDUneSolution;