814 get kgover information from data interface

sources/Algo/include/GeneratorDefinitionAlgorithm.h

@@ -165,12 +165,13 @@ class GeneratorDefinition {
    * @param targetP target active power of the generator
    * @param regulatedBusId the Bus Id this generator is regulating
    * @param isNuclear true if the energy source of this generator is nuclear
+   * @param hasActivePowerControl true if the generator has active power control information
    */
   GeneratorDefinition(const inputs::Generator::GeneratorId &genId, ModelType type, const inputs::Node::NodeId &nodeId,
                       const std::vector<ReactiveCurvePoint> &curvePoints, double qmin, double qmax, double pmin, double pmax, double q, double targetP,
-                      const BusId &regulatedBusId, bool isNuclear = false)
-      : id{genId}, model{type}, nodeId{nodeId},
-        points(curvePoints), qmin{qmin}, qmax{qmax}, pmin{pmin}, pmax{pmax}, q{q}, targetP{targetP}, regulatedBusId{regulatedBusId}, isNuclear{isNuclear} {}
+                      const BusId &regulatedBusId, bool isNuclear = false, bool hasActivePowerControl = false)
+      : id{genId}, model{type}, nodeId{nodeId}, points(curvePoints), qmin{qmin}, qmax{qmax}, pmin{pmin}, pmax{pmax}, q{q}, targetP{targetP},
+        regulatedBusId{regulatedBusId}, isNuclear{isNuclear}, hasActivePowerControl{hasActivePowerControl} {}
 
   inputs::Generator::GeneratorId id;       ///< generator id
   ModelType model;                         ///< model
@@ -184,6 +185,7 @@ class GeneratorDefinition {
   double targetP;                          ///< target active power of the generator
   const BusId regulatedBusId;              ///< regulated Bus Id
   const bool isNuclear;                    ///< true if the energy source of this generator is nuclear
+  const bool hasActivePowerControl;        ///< true if the generator has active power control information
 };
 
 /**

sources/Algo/src/GeneratorDefinitionAlgorithm.cpp

@@ -171,7 +171,7 @@ void GeneratorDefinitionAlgorithm::operator()(const NodePtr &node, std::shared_p
       }
     }
     generators_.emplace_back(generator.id, model, node->id, generator.points, generator.qmin, generator.qmax, generator.pmin, generator.pmax, generator.q,
-                             generator.targetP, generator.regulatedBusId, generator.isNuclear);
+                             generator.targetP, generator.regulatedBusId, generator.isNuclear, generator.hasActivePowerControl);
   }
 }
 

sources/Inputs/include/Behaviours.h

@@ -69,13 +69,14 @@ struct Generator {
    * @param regulatedBusId the Bus Id this generator is regulating
    * @param connectedBusId the Bus Id this generator is connected to
    * @param isNuclear true if the energy source of this generator is nuclear
+   * @param hasActivePowerControl true if the generator has active power control information
    */
   explicit Generator(const GeneratorId &genId, const bool isVoltageRegulationOn, const std::vector<ReactiveCurvePoint> &curvePoints, double qmin, double qmax,
                      double pmin, double pmax, double q, double targetP, double VNom, const BusId &regulatedBusId, const BusId &connectedBusId,
-                     bool isNuclear = false)
+                     bool isNuclear = false, bool hasActivePowerControl = false)
       : id{genId}, isVoltageRegulationOn{isVoltageRegulationOn},
         points(curvePoints), qmin{qmin}, qmax{qmax}, pmin{pmin}, pmax{pmax}, q{q}, targetP{targetP}, VNom{VNom}, regulatedBusId{regulatedBusId},
-        connectedBusId{connectedBusId}, isNuclear{isNuclear} {}
+        connectedBusId{connectedBusId}, isNuclear{isNuclear}, hasActivePowerControl{hasActivePowerControl} {}
 
   GeneratorId id;                          ///< generator id
   const bool isVoltageRegulationOn;        ///< determines if generator is regulating voltage or not
@@ -90,6 +91,7 @@ struct Generator {
   const BusId regulatedBusId;              ///< regulated Bus Id
   const BusId connectedBusId;              ///< connected Bus Id
   const bool isNuclear;                    ///< true if the energy source of this generator is nuclear
+  const bool hasActivePowerControl;        ///< true if the generator has active power control information
 };
 
 class HvdcLine;

sources/Inputs/src/NetworkManager.cpp

@@ -38,7 +38,6 @@
 #include <DYNVoltageLevelInterface.h>
 #include <DYNVscConverterInterface.h>
 
-
 namespace dfl {
 namespace inputs {
 
@@ -168,7 +167,7 @@ void NetworkManager::buildTree() {
       nodes_[nodeid]->generators.emplace_back(generator->getID(), generator->isVoltageRegulationOn(), generator->getReactiveCurvesPoints(),
                                               generator->getQMin(), generator->getQMax(), pmin, pmax, -generator->getQ(), targetP,
                                               generator->getBusInterface()->getVNom(), regulatedBusId, nodeid,
-                                              generator->getEnergySource() == DYN::GeneratorInterface::SOURCE_NUCLEAR);
+                                              generator->getEnergySource() == DYN::GeneratorInterface::SOURCE_NUCLEAR, generator->hasActivePowerControl());
       LOG(debug, NodeContainsGen, nodeid, generator->getID());
     }
 

sources/Outputs/include/ParGenerator.h

@@ -41,7 +41,7 @@ class ParGenerator {
    *
    * @param generatorDefinitions reference to the list of generator definitions
    */
-  explicit ParGenerator(const std::vector<algo::GeneratorDefinition>& generatorDefinitions) : generatorDefinitions_(generatorDefinitions) {}
+  explicit ParGenerator(const std::vector<algo::GeneratorDefinition> &generatorDefinitions) : generatorDefinitions_(generatorDefinitions) {}
 
   /**
    * @brief enrich the parameter set collection for generators
@@ -53,13 +53,9 @@ class ParGenerator {
    * @param startingPointMode starting point mode
    * @param dynamicDataBaseManager the dynamic DB manager to use
    */
-  void
-  write(boost::shared_ptr<parameters::ParametersSetCollection>& paramSetCollection,
-        ActivePowerCompensation activePowerCompensation,
-        const std::string& basename,
-        const boost::filesystem::path& dirname,
-        StartingPointMode startingPointMode,
-        const inputs::DynamicDataBaseManager& dynamicDataBaseManager);
+  void write(boost::shared_ptr<parameters::ParametersSetCollection> &paramSetCollection, ActivePowerCompensation activePowerCompensation,
+             const std::string &basename, const boost::filesystem::path &dirname, StartingPointMode startingPointMode,
+             const inputs::DynamicDataBaseManager &dynamicDataBaseManager);
 
  private:
   /**
@@ -80,7 +76,7 @@ class ParGenerator {
    * @param startingPointMode starting point mode
    * @return the new macro parameter set
    */
-  boost::shared_ptr<parameters::MacroParameterSet> buildGeneratorMacroParameterSet(const algo::GeneratorDefinition& def,
+  boost::shared_ptr<parameters::MacroParameterSet> buildGeneratorMacroParameterSet(const algo::GeneratorDefinition &def,
                                                                                    ActivePowerCompensation activePowerCompensation, double targetP,
                                                                                    StartingPointMode startingPointMode);
 
@@ -94,7 +90,7 @@ class ParGenerator {
    * @returns the parameter set
    */
   std::shared_ptr<parameters::ParametersSet> writeConstantGeneratorsSets(ActivePowerCompensation activePowerCompensation,
-                                                                           const algo::GeneratorDefinition& generator, StartingPointMode startingPointMode);
+                                                                         const algo::GeneratorDefinition &generator, StartingPointMode startingPointMode);
 
   /**
    * @brief Update parameter set with SignalN generator parameters and references
@@ -103,9 +99,10 @@ class ParGenerator {
    * @param activePowerCompensation the type of active power compensation
    * @param targetP generator targetP value
    * @param startingPointMode starting point mode
+   * @param hasActivePowerControl true if the generator has active power control information
    */
   void updateSignalNGenerator(std::shared_ptr<parameters::ParametersSet> set, dfl::inputs::Configuration::ActivePowerCompensation activePowerCompensation,
-                              double targetP, StartingPointMode startingPointMode);
+                              double targetP, StartingPointMode startingPointMode, bool hasActivePowerControl);
 
   /**
    * @brief Update parameter set with transformer parameters
@@ -123,7 +120,7 @@ class ParGenerator {
    * @param databaseSetting the settings found in setting file
    * @param Rcpl2 true if the model used is RPCL2, false otherwise
    */
-  void updateRpclParameters(std::shared_ptr<parameters::ParametersSet> set, const std::string& genId, const inputs::SettingDataBase::Set& databaseSetting,
+  void updateRpclParameters(std::shared_ptr<parameters::ParametersSet> set, const std::string &genId, const inputs::SettingDataBase::Set &databaseSetting,
                             bool Rcpl2);
 
   /**
@@ -135,18 +132,17 @@ class ParGenerator {
    *
    * @returns the parameter set
    */
-  std::shared_ptr<parameters::ParametersSet> writeGenerator(const algo::GeneratorDefinition& def, const std::string& basename,
-                                                              const boost::filesystem::path& dirname);
+  std::shared_ptr<parameters::ParametersSet> writeGenerator(const algo::GeneratorDefinition &def, const std::string &basename,
+                                                            const boost::filesystem::path &dirname);
 
   /**
-   * @brief determine value of kGover based on generator targetP value
+   * @brief
    *
+   * @param set the parameter set to update
+   * @param hasActivePowerControl if the generator has active power control information
    * @param targetP generator targetP value
-   * @returns kGover value
    */
-  inline double getKGoverValue(double targetP) {
-    return DYN::doubleIsZero(targetP) ? constants::kGoverNullValue_ : constants::kGoverDefaultValue_;
-  }
+  template <class T> void setKGover(T &set, const bool hasActivePowerControl, const double targetP);
 
   /**
    * @brief update a parameter set with information specific to remote voltage regulation for a generator
@@ -155,10 +151,10 @@ class ParGenerator {
    * @param def the generator definition to use
    * @param set the parameter set to be updated
    */
-  void updateRemoteRegulationParameters(const algo::GeneratorDefinition& def, std::shared_ptr<parameters::ParametersSet> set);
+  void updateRemoteRegulationParameters(const algo::GeneratorDefinition &def, std::shared_ptr<parameters::ParametersSet> set);
 
  private:
-  const std::vector<algo::GeneratorDefinition>& generatorDefinitions_;  ///< list of generators definitions
+  const std::vector<algo::GeneratorDefinition> &generatorDefinitions_;  ///< list of generators definitions
 };
 
 }  // namespace outputs

sources/Outputs/src/ParGenerator.cpp

@@ -44,7 +44,7 @@ void ParGenerator::write(boost::shared_ptr<parameters::ParametersSetCollection>
                            dynamicDataBaseManager.setting().getSet(dynamicDataBaseManager.assembling().getSingleAssociationFromGenerator(generator.id)),
                            generator.hasRpcl2());
       if (!generator.isUsingDiagram()) {
-        updateSignalNGenerator(paramSet, activePowerCompensation, generator.targetP, startingPointMode);
+        updateSignalNGenerator(paramSet, activePowerCompensation, generator.targetP, startingPointMode, generator.hasActivePowerControl);
       }
     }
     if (paramSet && generator.hasTransformer()) {
@@ -122,7 +122,7 @@ boost::shared_ptr<parameters::MacroParameterSet> ParGenerator::buildGeneratorMac
     }
 
     macroParameterSet->addReference(helper::buildReference("generator_PRef0Pu", "targetP_pu", "DOUBLE"));
-    macroParameterSet->addParameter(helper::buildParameter("generator_KGover", getKGoverValue(targetP)));
+    setKGover(macroParameterSet, def.hasActivePowerControl, targetP);
 
     switch (activePowerCompensation) {
     case ActivePowerCompensation::P:
@@ -192,8 +192,8 @@ boost::shared_ptr<parameters::MacroParameterSet> ParGenerator::buildGeneratorMac
 }
 
 void ParGenerator::updateSignalNGenerator(std::shared_ptr<parameters::ParametersSet> set, ActivePowerCompensation activePowerCompensation, double targetP,
-                                          StartingPointMode startingPointMode) {
-  set->addParameter(helper::buildParameter("generator_KGover", getKGoverValue(targetP)));
+                                          StartingPointMode startingPointMode, bool hasActivePowerControl) {
+  setKGover(set, hasActivePowerControl, targetP);
   set->addParameter(helper::buildParameter("generator_QMin", -constants::powerValueMax));
   set->addParameter(helper::buildParameter("generator_QMax", constants::powerValueMax));
   set->addParameter(helper::buildParameter("generator_PMin", -constants::powerValueMax));
@@ -240,7 +240,7 @@ std::shared_ptr<parameters::ParametersSet> ParGenerator::writeConstantGenerators
                                                                                      const algo::GeneratorDefinition &generator,
                                                                                      StartingPointMode startingPointMode) {
   auto set = parameters::ParametersSetFactory::newParametersSet(helper::getGeneratorParameterSetId(generator));
-  updateSignalNGenerator(set, activePowerCompensation, generator.targetP, startingPointMode);
+  updateSignalNGenerator(set, activePowerCompensation, generator.targetP, startingPointMode, generator.hasActivePowerControl);
   switch (generator.model) {
   case ModelType::PROP_SIGNALN_INFINITE:
   case ModelType::PROP_DIAGRAM_PQ_SIGNALN:
@@ -323,5 +323,17 @@ void ParGenerator::updateRpclParameters(std::shared_ptr<parameters::ParametersSe
   }
 }
 
+template <class T> void ParGenerator::setKGover(T &set, const bool hasActivePowerControl, const double targetP) {
+  if (DYN::doubleIsZero(targetP)) {
+    set->addParameter(helper::buildParameter("generator_KGover", constants::kGoverNullValue_));
+  } else {
+    if (hasActivePowerControl) {
+      set->addReference(helper::buildReference("generator_KGover", "kGover", "DOUBLE"));
+    } else {
+      set->addParameter(helper::buildParameter("generator_KGover", constants::kGoverDefaultValue_));
+    }
+  }
+}
+
 }  // namespace outputs
 }  // namespace dfl

tests/main/CMakeLists.txt

@@ -33,6 +33,7 @@ DEFINE_LAUNCH_TEST(launch_diagram)
 DEFINE_LAUNCH_TEST(launch_diagram_tfo)
 
 DEFINE_LAUNCH_TEST(launch_P)
+DEFINE_LAUNCH_TEST(launch_kGover)
 
 DEFINE_LAUNCH_TEST(launch_infinite)
 

tests/main/reference/launch_kGover/Network.par

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<parametersSet xmlns="http://www.rte-france.com/dynawo">
+  <set id="Network">
+    <par name="capacitor_no_reclosing_delay" type="DOUBLE" value="300"/>
+    <par name="dangling_line_currentLimit_maxTimeOperation" type="DOUBLE" value="90"/>
+    <par name="line_currentLimit_maxTimeOperation" type="DOUBLE" value="90"/>
+    <par name="load_Tp" type="DOUBLE" value="90"/>
+    <par name="load_Tq" type="DOUBLE" value="90"/>
+    <par name="load_alpha" type="DOUBLE" value="0"/>
+    <par name="load_alphaLong" type="DOUBLE" value="0"/>
+    <par name="load_beta" type="DOUBLE" value="0"/>
+    <par name="load_betaLong" type="DOUBLE" value="0"/>
+    <par name="load_isControllable" type="BOOL" value="false"/>
+    <par name="load_isRestorative" type="BOOL" value="false"/>
+    <par name="load_zPMax" type="DOUBLE" value="100"/>
+    <par name="load_zQMax" type="DOUBLE" value="100"/>
+    <par name="reactance_no_reclosing_delay" type="DOUBLE" value="0"/>
+    <par name="startingPointMode" type="STRING" value="warm"/>
+    <par name="transformer_currentLimit_maxTimeOperation" type="DOUBLE" value="90"/>
+    <par name="transformer_t1st_HT" type="DOUBLE" value="60"/>
+    <par name="transformer_t1st_THT" type="DOUBLE" value="30"/>
+    <par name="transformer_tNext_HT" type="DOUBLE" value="10"/>
+    <par name="transformer_tNext_THT" type="DOUBLE" value="10"/>
+    <par name="transformer_tolV" type="DOUBLE" value="0.014999999700000001"/>
+  </set>
+</parametersSet>