Add batteries in the metrix-simulator section

docs/simulator/io_doc.md

@@ -685,7 +685,7 @@ curative diffère de la consigne préventive sont affichées
 (io-table_r9)=
 **Tableau R9** : résultats de la fonction objectif
 
-*Format* : ```R9 ;FCT OBJECTIF;COUT GROUPES;COUT DELESTAGE;VOLUME ECARTS N-k;VOLUME ECARTS N;COUT GRP CUR;COUT CONSO CUR;```
+*Format* : ```R9 ;FCT OBJECTIF;COUT GROUPES HORS BATTERIES;COUT BATTERIES;COUT DELESTAGE;VOLUME ECARTS N-k;VOLUME ECARTS N;COUT GRP HORS BATTERIES CUR;COUT BATTERIES CUR;COUT CONSO CUR;```
 
 | Nom de la grandeur                 | Type | Unité | Description                                                                   |
 |:-----------------------------------|:-----|:------|:------------------------------------------------------------------------------|

metrix-simulator/cmake/tnr.cmake

@@ -39,6 +39,8 @@ endfunction()
 
 if (WITH_LODF_PTDF)
     execute_process(COMMAND ${EXE} metrixOut.txt VariantSet.csv out 0 ${NB_TESTS} --write-PTDF --write-LODF  RESULT_VARIABLE cmd_result)
+elseif(ALL_OUTPUTS)
+    execute_process(COMMAND ${EXE} metrixOut.txt VariantSet.csv out 0 ${NB_TESTS} --all-outputs  RESULT_VARIABLE cmd_result)
 else()
     execute_process(COMMAND ${EXE} metrixOut.txt VariantSet.csv out 0 ${NB_TESTS}  RESULT_VARIABLE cmd_result)
 endif()

metrix-simulator/src/config/constants.h

@@ -81,5 +81,7 @@ constexpr double singularisation_parade = 0.; // légère pénalisation du Tmax
 
 constexpr double display_margin_variation_threshold = 0.000005;
 
+const std::string battery_type = "BATTERIE";
+
 } // namespace constants
 } // namespace config

metrix-simulator/src/metrix2assess.cpp

@@ -32,7 +32,8 @@ using cte::c_fmt;
 
 using std::string;
 using std::vector;
-
+using std::list;
+using std::tuple;
 
 static constexpr double EPSILON_SORTIES = 0.05; // seuil de precision pour les sorties
 static const string PREC_FLOAT = "%.1f";        // Doit etre coherent avec EPSILON_SORTIE
@@ -191,7 +192,10 @@ int Calculer::metrix2Assess(const std::shared_ptr<Variante>& var, const vector<d
             fprintf(fr, "S1 ;INDISPONIBILITE; OUVRAGE;\n");
             if (var->num_ != -1) {
                 for (const auto& grp : var->grpIndispo_) {
-                    fprintf(fr, "S1 ;;2; %s;\n", grp->nom_.c_str());
+                    constexpr unsigned int ouvrageTypeBattery = 3;
+                    constexpr unsigned int ouvrageTypeGroupWithoutBattery = 2;
+                    const int grpType = grp->isBattery() ? ouvrageTypeBattery : ouvrageTypeGroupWithoutBattery;
+                    fprintf(fr, "S1 ;;%d; %s;\n", grpType, grp->nom_.c_str());
                 }
                 for (const auto& quad : var->indispoLignes_) {
                     fprintf(fr, "S1 ;;1; %s;\n", quad->nom_.c_str());
@@ -560,8 +564,8 @@ int Calculer::metrix2Assess(const std::shared_ptr<Variante>& var, const vector<d
             }
         } // End R1C
 
-        // ecriture : R2. Productions groupe
-        //---------------------------------
+        // ecriture : R2. Productions groupe (hors batteries et batteries)
+        //----------------------------------------------------------------
 
         vector<double> redispatchParTypeH(res_.nbTypesGroupes_, 0.);
         vector<double> redispatchParTypeB(res_.nbTypesGroupes_, 0.);
@@ -685,14 +689,17 @@ int Calculer::metrix2Assess(const std::shared_ptr<Variante>& var, const vector<d
             }
         }
 
-        // ecriture : R2B: Curatif des groupes
-        //--------------
+        // recuperation : R2B: Curatif des groupes hors batteries
+        // recuperation : R2D: Curatif des groupes batteries
+        //-------------------------------------------------------
         vector<double> maxRedispCurParTypeH(res_.nbTypesGroupes_, 0.);
         vector<double> maxRedispCurParTypeB(res_.nbTypesGroupes_, 0.);
         vector<double> redispCurParType(res_.nbTypesGroupes_, 0.);
 
+        list<tuple<const int, const string, const double>> nonBatteriesResults;
+        list<tuple<const int, const string, const double>> batteriesResults;
+
         if (res_.nbGroupesCuratifs_ > 0) {
-            fprintf(fr, "R2B ;INCIDENT;NOM GROUPE;DELTA_P;\n");
 
             for (const auto& elem : res_.incidents_) {
                 const auto& icdt = elem.second;
@@ -726,7 +733,7 @@ int Calculer::metrix2Assess(const std::shared_ptr<Variante>& var, const vector<d
                         pos = elemC->positionVarCurative_;
                         if (pos != -1) {
                             const auto& grp = std::dynamic_pointer_cast<ElementCuratifGroupe>(elemC)->groupe_;
-                            string s = grp->nom_;
+                            string grpName = grp->nom_;
 
                             double val = pbX_[pos] - pbX_[pos + 1];
 
@@ -742,11 +749,14 @@ int Calculer::metrix2Assess(const std::shared_ptr<Variante>& var, const vector<d
                             if (config::inputConfiguration().useAllOutputs()
                                 || (config::configuration().displayResultatsRedispatch()
                                     && fabs(val) >= EPSILON_SORTIES)) {
-                                fprintf(fr,
-                                        ("R2B ;%d;%s;" + PREC_FLOAT + ";\n").c_str(),
-                                        incidentsContraignants.find(icdt)->second,
-                                        s.c_str(),
-                                        val);
+                                tuple<const int, const string, const double> tupleToAdd(incidentsContraignants.find(icdt)->second, grpName, val);
+                                if (grp->isBattery()) {
+                                    batteriesResults.push_back(tupleToAdd);
+                                }
+                                else {
+                                    nonBatteriesResults.push_back(tupleToAdd);
+                                }
+
                             }
                         }
                     }
@@ -760,6 +770,25 @@ int Calculer::metrix2Assess(const std::shared_ptr<Variante>& var, const vector<d
             }     // end for incident
         }         // End R2B
 
+        // ecriture : R2B: Curatif des groupes hors batteries
+        // ecriture : R2D: Curatif des groupes batteries
+        //---------------
+        if (res_.nbGroupesCuratifs_ > 0) {
+            fprintf(fr, "R2B ;INCIDENT;NOM GROUPE (HORS BATTERIE);DELTA_P;\n");
+        }
+        for (auto& itLog : nonBatteriesResults) {
+            fprintf(fr, ("R2B ;%d;%s;" + PREC_FLOAT + ";\n").c_str(),
+-                                        std::get<0>(itLog), std::get<1>(itLog).c_str(), std::get<2>(itLog));
+        }
+        nonBatteriesResults.clear();
+        if (res_.nbGroupesCuratifs_ > 0) {
+            fprintf(fr, "R2D ;INCIDENT;NOM BATTERIE;DELTA_P;\n");
+        }
+        for (auto& itLog : batteriesResults) {
+            fprintf(fr, ("R2D ;%d;%s;" + PREC_FLOAT + ";\n").c_str(),
+-                                        std::get<0>(itLog), std::get<1>(itLog).c_str(), std::get<2>(itLog));
+        }
+        batteriesResults.clear();
         // ecriture : R2C: Couplages de groupes
         //---------------
         if (res_.nbGroupesCouples_ > 0) {
@@ -1209,14 +1238,24 @@ int Calculer::metrix2Assess(const std::shared_ptr<Variante>& var, const vector<d
         fprintf(fr, "R7 ;PAR FILIERE;TYPE;VOL BAISSE;VOL HAUSSE;VOL CUR BAISSE;VOL CUR HAUSSE;\n");
         double volGrp = 0.;
         double volGrpCur = 0.;
+        double volGrpBattery = 0.;
+        double volGrpBatteryCur = 0.;
         for (int i = 0; i < res_.nbTypesGroupes_; ++i) {
             if (redispatchParTypeB[i] < EPSILON_SORTIES && redispatchParTypeH[i] < EPSILON_SORTIES
                 && maxRedispCurParTypeB[i] < EPSILON_SORTIES && maxRedispCurParTypeH[i] < EPSILON_SORTIES) {
                 continue;
             }
 
-            volGrp += redispatchParTypeB[i] + redispatchParTypeH[i];
-            volGrpCur += redispCurParType[i];
+            if(res_.typesGroupes_[i] == config::constants::battery_type)
+            {
+                volGrpBattery += redispatchParTypeB[i] + redispatchParTypeH[i];
+                volGrpBatteryCur += redispCurParType[i];
+            }
+            else
+            {
+                volGrp += redispatchParTypeB[i] + redispatchParTypeH[i];
+                volGrpCur += redispCurParType[i];
+            }
 
             fprintf(fr,
                     "R7 ;;%s;%s;%s;%s;%s;\n",
@@ -1253,32 +1292,92 @@ int Calculer::metrix2Assess(const std::shared_ptr<Variante>& var, const vector<d
         // ecriture : R9.
         //--------------
         fprintf(fr,
-                "R9 ;FCT OBJECTIF;COUT GROUPES;COUT DELESTAGE;VOLUME ECARTS N-k;VOLUME ECARTS N;COUT GRP CUR;COUT "
+                "R9 ;FCT OBJECTIF;COUT GROUPES HORS BATTERIES;COUT BATTERIES;COUT DELESTAGE;VOLUME ECARTS N-k;VOLUME ECARTS N;COUT GRP HORS BATTERIES CUR;COUT BATTERIES CUR;COUT "
                 "CONSO CUR;\n");
         string coutGrpCur;
+        string coutGrpBatteryCur;
         string coutConsoCur;
 
-        // on ote les offsets dans les couts restitues pour les groupes
-        double coutGrp = fonction_objectif_G_ - (volGrp * config::configuration().redispatchCostOffset());
-        double coutGrpC = fonction_objectif_G_cur_sans_offset_;
+        double fonction_objectif_G_battery_prev = 0.0;
+        for (const auto& elem : res_.groupes_) {
+            const auto& grp = elem.second;
+            if (grp->isBattery() && grp->prodAjust_ != Groupe::NON_HR_AR && grp->etat_) {
+                int numVar = grp->numVarGrp_;
+                fonction_objectif_G_battery_prev += pbCoutLineaire_[numVar] * pbX_[numVar];
+                fonction_objectif_G_battery_prev += pbCoutLineaire_[numVar + 1] * pbX_[numVar + 1];
+            }
+        }
+
+        double coutGrpBatteryC = 0.0;
+
+        for (const auto& elem : res_.incidents_) {
+            const auto& icdt = elem.second;
+
+            if (!icdt->validite_) {
+                continue;
+            }
+
+            auto tmpListeElemCur = icdt->listeElemCur_;
+
+            // Prendre en compte les parades activées
+            if (icdt->paradesActivees_) {
+                for (const auto& parade : icdt->parades_) {
+                    if ((parade->numVarActivation_ != -1) && (pbX_[parade->numVarActivation_] > 0.5)) {
+                        tmpListeElemCur = parade->listeElemCur_;
+                        break;
+                    }
+                }
+            }
+
+            // Parcourir les éléments curatifs de cet incident
+            for (const auto& elemC : tmpListeElemCur) {
+                if (elemC->typeElem_ != ElementCuratif::GROUPE) {
+                    continue;
+                }
+
+                int pos = elemC->positionVarEntiereCur_;
+                if ((pos == -1) || (pbX_[pos] > 0.5)) { // Curatif activé sur cette parade
+                    pos = elemC->positionVarCurative_;
+                    if (pos != -1) {
+                        const auto& grp = std::dynamic_pointer_cast<ElementCuratifGroupe>(elemC)->groupe_;
+
+                        // Si c'est une batterie, accumuler son coût curatif
+                        if (grp->isBattery()) {
+                            coutGrpBatteryC += pbCoutLineaireSansOffset_[pos] * pbX_[pos];
+                            coutGrpBatteryC += pbCoutLineaireSansOffset_[pos + 1] * pbX_[pos + 1];
+                        }
+                    }
+                }
+            }
+        }
+
+        double coutGrp = (fonction_objectif_G_ - fonction_objectif_G_battery_prev) 
+                 - (volGrp * config::configuration().redispatchCostOffset());
+        double coutGrpBattery = fonction_objectif_G_battery_prev 
+                                - (volGrpBattery * config::configuration().redispatchCostOffset());
+        double coutGrpC = fonction_objectif_G_cur_sans_offset_ - coutGrpBatteryC;
         double coutConso = fonction_objectif_D_ - (volDel * config::configuration().redispatchCostOffset());
         double coutConsoC = fonction_objectif_D_cur_sans_offset_;
 
         if (coutGrpC >= EPSILON_SORTIES) {
             coutGrpCur = c_fmt(PREC_FLOAT.c_str(), coutGrpC);
         }
-
+        if (coutGrpBatteryC >= EPSILON_SORTIES) {
+            coutGrpBatteryCur = c_fmt(PREC_FLOAT.c_str(), coutGrpBatteryC);
+        }
         if (fonction_objectif_D_cur_ >= EPSILON_SORTIES) {
             coutConsoCur = c_fmt(PREC_FLOAT.c_str(), coutConsoC);
         }
 
         fprintf(fr,
-                ("R9 ;;" + PREC_FLOAT + ";" + PREC_FLOAT + ";" + PREC_FLOAT + ";" + PREC_FLOAT + ";%s;%s;\n").c_str(),
+                ("R9 ;;" + PREC_FLOAT + ";" + PREC_FLOAT + ";" + PREC_FLOAT + ";" + PREC_FLOAT + ";" + PREC_FLOAT + ";%s;%s;%s;\n").c_str(),
                 coutGrp,
+                coutGrpBattery,
                 coutConso,
                 sommeEcartsNk_,
                 sommeEcartsN,
                 coutGrpCur.c_str(),
+                coutGrpBatteryCur.c_str(),
                 coutConsoCur.c_str());
 
         // ecriture : R10

metrix-simulator/src/reseau.cpp

@@ -7,7 +7,8 @@
 // file, you can obtain one at http://mozilla.org/MPL/2.0/.
 // SPDX-License-Identifier: MPL-2.0
 //
-
+#include <algorithm>
+#include <cctype> 
 #include <cmath>
 #include <cstdio>
 #include <iomanip>
@@ -119,6 +120,11 @@ bool Groupe::estAjustable(bool adequacy) const
     return true;
 }
 
+bool Groupe::isBattery() const
+{
+    return isBattery_;
+}
+
 void Reseau::update_with_configuration()
 {
     const auto& configuration = config::configuration();
@@ -501,6 +507,8 @@ void Reseau::lireDonnees()
     // Types des groupes
     for (unsigned int i = 0; i < static_cast<unsigned int>(nbTypesGroupes_); ++i) {
         string typeGroupe = config.trnomtypDIE()[i];
+        std::transform(typeGroupe.begin(), typeGroupe.end(), typeGroupe.begin(),
+                   [](unsigned char c) { return std::toupper(c); });
         rtrim(typeGroupe);
         typesGroupes_.push_back(typeGroupe);
     }
@@ -553,6 +561,13 @@ void Reseau::lireDonnees()
             trdembanDIE = config.trdembanDIE()[i];
         }
 
+        string grpTypeStr = "";
+        if(static_cast<unsigned int>(config.trtypgrpDIE().size()) > i && static_cast<int>(config.trnomtypDIE().size()) > config.trtypgrpDIE()[i]) {
+            grpTypeStr = config.trnomtypDIE()[config.trtypgrpDIE()[i]];
+            std::transform(grpTypeStr.begin(), grpTypeStr.end(), grpTypeStr.begin(),
+                [](unsigned char c) { return std::toupper(c); });
+            rtrim(grpTypeStr);
+        };
         auto prod = std::make_shared<Groupe>(i,
                                              nomGroupe,
                                              noeuds_[indNoeudRaccord],
@@ -561,7 +576,9 @@ void Reseau::lireDonnees()
                                              config.trpuiminDIE()[i],
                                              config.trvalpmdDIE()[i],
                                              trdembanDIE,
-                                             ajustMode);
+                                             ajustMode,
+                                             grpTypeStr == config::constants::battery_type
+                                             );
 
 
         groupes_.insert(std::pair<string, std::shared_ptr<Groupe>>(prod->nom_, prod));
@@ -1432,7 +1449,8 @@ Groupe::Groupe(int num,
                float puisMin,
                float puisMaxDispo,
                float demiBande,
-               Groupe::ProdAjustable pimpmod) :
+               Groupe::ProdAjustable pimpmod,
+               bool isBattery) :
     nom_(nom),
     num_(num),
     numNoeud_{noeud->num_},
@@ -1441,7 +1459,8 @@ Groupe::Groupe(int num,
     prodAjust_(pimpmod),
     puisMinBase_(puisMin),
     puisMinAR_(puisMin),
-    demiBande_(demiBande)
+    demiBande_(demiBande),
+    isBattery_(isBattery)
 {
     noeud->listeGroupes_.push_back(this);
     noeud->nbGroupes_++;

metrix-simulator/src/reseau.h

@@ -347,6 +347,8 @@ class Groupe
     // Curatif
     std::set<int> incidentsAtraiterCuratif_; // incidents a traiter en curatif
 
+    bool isBattery_; /* Vrai si de type 'Battery', Faux sinon */
+
     Groupe(int num,
            const std::string& nom,
            const std::shared_ptr<Noeud>& noeud,
@@ -355,13 +357,16 @@ class Groupe
            float puisMin,
            float puisMaxDispo,
            float demiBande,
-           Groupe::ProdAjustable pimpmod);
+           Groupe::ProdAjustable pimpmod,
+           bool isBattery);
     ~Groupe() = default;
     Groupe(const Groupe&) = delete;            // Constructeur de copie
     Groupe& operator=(const Groupe&) = delete; // Operateur d'affectation
 
     int checkCoherencePminMaxObj();
     bool estAjustable(bool adequacy) const;
+
+    bool isBattery() const;
 };
 
 class GroupesCouples