diff --git a/sources/API/aggregatedResults/DYNAggrResXmlExporter.cpp b/sources/API/aggregatedResults/DYNAggrResXmlExporter.cpp index bceb1602..7b14e16a 100644 --- a/sources/API/aggregatedResults/DYNAggrResXmlExporter.cpp +++ b/sources/API/aggregatedResults/DYNAggrResXmlExporter.cpp @@ -68,7 +68,7 @@ XmlExporter::exportScenarioResultsToStream(const vector& resul void -XmlExporter::exportLoadIncreaseResultsToFile(const vector& results, const string& filePath) const { +XmlExporter::exportLoadIncreaseResultsToFile(const std::map& results, const string& filePath) const { ofstream file; file.open(filePath.c_str(), std::ios::binary); if (!file.is_open()) { @@ -80,20 +80,21 @@ XmlExporter::exportLoadIncreaseResultsToFile(const vector& r } void -XmlExporter::exportLoadIncreaseResultsToStream(const vector& results, ostream& stream) const { +XmlExporter::exportLoadIncreaseResultsToStream(const std::map& results, ostream& stream) const { FormatterPtr formatter = Formatter::createFormatter(stream, "http://www.rte-france.com/dynawo"); formatter->startDocument(); AttributeList attrs; formatter->startElement("aggregatedResults", attrs); - for (size_t i=0, iEnd = results.size(); i < iEnd; i++) { + + for (auto loadIncreaseResultIt = results.begin(); loadIncreaseResultIt != results.end(); ++loadIncreaseResultIt) { + const LoadIncreaseResult& result = loadIncreaseResultIt->second; attrs.clear(); - const DYNAlgorithms::LoadIncreaseResult& loadIncreaseRes = results[i]; - attrs.add("loadLevel", loadIncreaseRes.getLoadLevel()); - attrs.add("status", getStatusAsString(loadIncreaseRes.getStatus())); + attrs.add("loadLevel", result.getPreScenariosLoadIncreaseResult().getVariation()); + attrs.add("status", getStatusAsString(result.getPreScenariosLoadIncreaseResult().getStatus())); formatter->startElement("loadIncreaseResults", attrs); - if (loadIncreaseRes.getStatus() == DYNAlgorithms::CONVERGENCE_STATUS) { - appendScenarioResultsElement(loadIncreaseRes.getScenariosResults(), formatter); + if (result.getPreScenariosLoadIncreaseResult().getStatus() == DYNAlgorithms::CONVERGENCE_STATUS) { + appendScenarioResultsElement(result.getScenariosResults(), formatter); } formatter->endElement(); // loadIncreaseResults } diff --git a/sources/API/aggregatedResults/DYNAggrResXmlExporter.h b/sources/API/aggregatedResults/DYNAggrResXmlExporter.h index 7d15ba35..2076cbf6 100644 --- a/sources/API/aggregatedResults/DYNAggrResXmlExporter.h +++ b/sources/API/aggregatedResults/DYNAggrResXmlExporter.h @@ -50,7 +50,7 @@ class XmlExporter { * @param results aggregated results to export * @param filePath file where the results must be exported */ - void exportLoadIncreaseResultsToFile(const std::vector& results, const std::string& filePath) const; + void exportLoadIncreaseResultsToFile(const std::map& results, const std::string& filePath) const; /** * @brief Export load increase results into a steam @@ -58,7 +58,7 @@ class XmlExporter { * @param results aggregated results to export * @param stream stream where the results must be exported */ - void exportLoadIncreaseResultsToStream(const std::vector& results, std::ostream& stream) const; + void exportLoadIncreaseResultsToStream(const std::map& results, std::ostream& stream) const; private: /** diff --git a/sources/Common/DYNLoadIncreaseResult.cpp b/sources/Common/DYNLoadIncreaseResult.cpp index 60cf5cb2..d9356eed 100644 --- a/sources/Common/DYNLoadIncreaseResult.cpp +++ b/sources/Common/DYNLoadIncreaseResult.cpp @@ -15,54 +15,14 @@ namespace DYNAlgorithms { -LoadIncreaseResult::LoadIncreaseResult(): -status_(EXECUTION_PROBLEM_STATUS), -loadLevel_(-1.) { } - -LoadIncreaseResult::~LoadIncreaseResult() { } - -double -LoadIncreaseResult::getLoadLevel() const { - return loadLevel_; -} - -void -LoadIncreaseResult::setLoadLevel(double loadLevel) { - loadLevel_ = loadLevel; -} - -status_t -LoadIncreaseResult::getStatus() const { - return status_; -} - -void -LoadIncreaseResult::setStatus(status_t status) { - status_ = status; -} - -void -LoadIncreaseResult::resize(size_t nbScenarios) { - scenariosResults_.resize(nbScenarios); +LoadIncreaseResult::LoadIncreaseResult(const SimulationResult& preScenariosLoadIncreaseResult, + const size_t nbScenarios) : + preScenariosLoadIncreaseResult_(preScenariosLoadIncreaseResult) { + scenariosResults_.resize(nbScenarios); } SimulationResult& LoadIncreaseResult::getScenarioResult(size_t idx) { - assert(idx < scenariosResults_.size()); - return scenariosResults_[idx]; -} - -const std::vector& -LoadIncreaseResult::getScenariosResults() const { - return scenariosResults_; -} - -std::vector::const_iterator LoadIncreaseResult::begin() const { - return scenariosResults_.begin(); -} - -std::vector::const_iterator LoadIncreaseResult::end() const { - return scenariosResults_.end(); + return scenariosResults_.at(idx); } - } // namespace DYNAlgorithms diff --git a/sources/Common/DYNLoadIncreaseResult.h b/sources/Common/DYNLoadIncreaseResult.h index 7cf32b95..5bf96751 100644 --- a/sources/Common/DYNLoadIncreaseResult.h +++ b/sources/Common/DYNLoadIncreaseResult.h @@ -29,40 +29,11 @@ namespace DYNAlgorithms { class LoadIncreaseResult { public: /** - * @brief default constructor + * @brief constructor */ - LoadIncreaseResult(); + explicit LoadIncreaseResult(const SimulationResult& preScenariosLoadIncreaseResult, const size_t nbScenarios); - /** - * @brief default destructor - */ - ~LoadIncreaseResult(); - - /** - * @brief get the load level of the load increase - * @return load level of the load increase - */ - double getLoadLevel() const; - - /** - * @brief set the load level of the load increase - * @param loadLevel value to apply - */ - void setLoadLevel(double loadLevel); - - /** - * @brief get the status of the load increase - * @return status of the load increase - */ - status_t getStatus() const; - - /** - * @brief set the status of the load increase - * @param status value to apply - */ - void setStatus(status_t status); - - SimulationResult getPreScenariosLoadIncreaseResult() const { + const SimulationResult& getPreScenariosLoadIncreaseResult() const { return preScenariosLoadIncreaseResult_; } @@ -70,18 +41,6 @@ class LoadIncreaseResult { preScenariosLoadIncreaseResult_ = preScenariosLoadIncreaseResult; } - /** - * @brief specify the number of scenarios - * @param nbScenarios number of scenarios - */ - void resize(size_t nbScenarios); - - /** - * @brief getter of the number of scenarios - * @return the number of scenarios - */ - size_t size() const {return scenariosResults_.size();} - /** * @brief result getter * @param idx id of the result @@ -93,25 +52,13 @@ class LoadIncreaseResult { * @brief getter for the results * @return results associated to this load increase */ - const std::vector& getScenariosResults() const; - - /** - * @brief begin iterator on simulation results - * @return begin iterator on the first result - */ - std::vector::const_iterator begin() const; - - /** - * @brief end iterator on simulation results - * @return end iterator on the first result - */ - std::vector::const_iterator end() const; + const std::vector& getScenariosResults() const { + return scenariosResults_; + } private: SimulationResult preScenariosLoadIncreaseResult_; std::vector scenariosResults_; ///< list of scenario results - status_t status_; ///< status of the load increase - double loadLevel_; ///< value of the variation of the load increase }; } // namespace DYNAlgorithms diff --git a/sources/Launcher/DYNComputeLoadVariationLauncher.cpp b/sources/Launcher/DYNComputeLoadVariationLauncher.cpp index 33b0a0fd..b9c4754d 100644 --- a/sources/Launcher/DYNComputeLoadVariationLauncher.cpp +++ b/sources/Launcher/DYNComputeLoadVariationLauncher.cpp @@ -99,11 +99,11 @@ ComputeLoadVariationLauncher::launch() { simulation->setStopTime(job->getSimulationEntry()->getStopTime() - (100. - variation_)/100. * duration); simulate(simulation, result); } - LoadIncreaseResult loadResult; - loadResult.setLoadLevel(variation_); - loadResult.setStatus(result.getStatus()); - std::vector results; - results.push_back(loadResult); + std::map results; + result.setVariation(variation_); + results.emplace(std::piecewise_construct, + std::forward_as_tuple(result.getVariation()), + std::forward_as_tuple(result, 0)); aggregatedResults::XmlExporter exporter; exporter.exportLoadIncreaseResultsToFile(results, outputFileFullPath_); std::cout << "End of load increase simulation status: " + getStatusAsString(result.getStatus()) << std::endl; diff --git a/sources/Launcher/DYNMarginCalculationLauncher.cpp b/sources/Launcher/DYNMarginCalculationLauncher.cpp index cb6e56a5..3a13bcb1 100644 --- a/sources/Launcher/DYNMarginCalculationLauncher.cpp +++ b/sources/Launcher/DYNMarginCalculationLauncher.cpp @@ -149,30 +149,30 @@ MarginCalculationLauncher::launch() { for (size_t i=0, iEnd = events.size(); i < iEnd ; i++) allEvents.push_back(i); toRun.push(task_t(maxVariation, maxVariation, allEvents)); - - results_.push_back(LoadIncreaseResult()); - size_t idx = results_.size() - 1; - results_[idx].setPreScenariosLoadIncreaseResult(resultMaxVariation); - results_[idx].resize(events.size()); - results_[idx].setLoadLevel(maxVariation); + const auto resultIt1 = results_.emplace(std::piecewise_construct, + std::forward_as_tuple(resultMaxVariation.getVariation()), + std::forward_as_tuple(resultMaxVariation, events.size())); + if (!resultIt1.second) { + throw std::runtime_error("Load increase result already added"); + } + LoadIncreaseResult& loadIncreaseResult1 = resultIt1.first->second; // step one : launch the loadIncrease and then all events with 100% of the load increase // if there is no crash => no need to go further // We start with 100% as it is the most common result of margin calculations on real large cases - results_[idx].setStatus(resultMaxVariation.getStatus()); std::vector maximumVariationPassing(events.size(), 0.); if (resultMaxVariation.getSuccess()) { if (!DYN::doubleEquals(minVariation, maxVariation)) findAllLevelsBetween(minVariation, maxVariation, marginCalculation->getAccuracy(), allEvents, toRun); - findOrLaunchScenarios(baseJobsFile, events, toRun, results_[idx]); + findOrLaunchScenarios(baseJobsFile, events, toRun, loadIncreaseResult1); // analyze results unsigned int nbSuccess = 0; size_t id = 0; - for (std::vector::const_iterator it = results_[idx].begin(), - itEnd = results_[idx].end(); it != itEnd; ++it, ++id) { - TraceInfo(logTag_) << DYNAlgorithmsLog(ScenariosEnd, it->getUniqueScenarioId(), getStatusAsString(it->getStatus())) << Trace::endline; - if (it->getStatus() == CONVERGENCE_STATUS) { // event OK + for (const SimulationResult& simulationResult : loadIncreaseResult1.getScenariosResults()) { + TraceInfo(logTag_) << DYNAlgorithmsLog(ScenariosEnd, + simulationResult.getUniqueScenarioId(), getStatusAsString(simulationResult.getStatus())) << Trace::endline; + if (simulationResult.getStatus() == CONVERGENCE_STATUS) { // event OK nbSuccess++; maximumVariationPassing[id] = maxVariation; } @@ -218,16 +218,17 @@ MarginCalculationLauncher::launch() { double value = computeGlobalMargin(loadIncrease, baseJobsFile, events, maximumVariationPassing, marginCalculation->getAccuracy(), minVariation, maxVariation); if (value < marginCalculation->getAccuracy()) { - results_.push_back(LoadIncreaseResult()); - idx = results_.size() - 1; - results_[idx].resize(events.size()); - results_[idx].setLoadLevel(minVariation); // step two : launch the loadIncrease and then all events with 0% of the load increase // if one event crash => no need to go further SimulationResult result0; findOrLaunchLoadIncrease(loadIncrease, minVariation, minVariation, minVariation, marginCalculation->getAccuracy(), result0); - results_[idx].setPreScenariosLoadIncreaseResult(result0); - results_[idx].setStatus(result0.getStatus()); + const auto resultIt2 = results_.emplace(std::piecewise_construct, + std::forward_as_tuple(result0.getVariation()), + std::forward_as_tuple(result0, events.size())); + if (!resultIt2.second) { + throw std::runtime_error("Load increase result already added"); + } + LoadIncreaseResult& loadIncreaseResult2 = resultIt2.first->second; double variation0 = minVariation; if (result0.getSuccess()) { toRun = std::queue< task_t >(); @@ -237,14 +238,14 @@ MarginCalculationLauncher::launch() { eventsIds.push_back(i); } else { TraceInfo(logTag_) << DYNAlgorithmsLog(ScenarioNotSimulated, events[i]->getId()) << Trace::endline; - results_[idx].getScenarioResult(i).setScenarioId(events[i]->getId()); - results_[idx].getScenarioResult(i).setVariation(minVariation); - results_[idx].getScenarioResult(i).setSuccess(true); - results_[idx].getScenarioResult(i).setStatus(CONVERGENCE_STATUS); + loadIncreaseResult2.getScenarioResult(i).setScenarioId(events[i]->getId()); + loadIncreaseResult2.getScenarioResult(i).setVariation(minVariation); + loadIncreaseResult2.getScenarioResult(i).setSuccess(true); + loadIncreaseResult2.getScenarioResult(i).setStatus(CONVERGENCE_STATUS); } } toRun.push(task_t(0., 0., eventsIds)); - findOrLaunchScenarios(baseJobsFile, events, toRun, results_[idx]); + findOrLaunchScenarios(baseJobsFile, events, toRun, loadIncreaseResult2); } else { TraceInfo(logTag_) << "============================================================ " << Trace::endline; TraceInfo(logTag_) << DYNAlgorithmsLog(LocalMarginValueLoadIncrease, minVariation) << Trace::endline; @@ -257,8 +258,8 @@ MarginCalculationLauncher::launch() { } // analyze results - for (std::vector::const_iterator it = results_[idx].begin(), - itEnd = results_[idx].end(); it != itEnd; ++it) { + for (std::vector::const_iterator it = loadIncreaseResult2.getScenariosResults().begin(), + itEnd = loadIncreaseResult2.getScenariosResults().end(); it != itEnd; ++it) { TraceInfo(logTag_) << DYNAlgorithmsLog(ScenariosEnd, it->getUniqueScenarioId(), getStatusAsString(it->getStatus())) << Trace::endline; if (it->getStatus() != CONVERGENCE_STATUS) { // one event crashes cleanResultDirectories(events); @@ -293,26 +294,26 @@ MarginCalculationLauncher::launch() { } } if (!eventsIds.empty()) { - results_.push_back(LoadIncreaseResult()); - idx = results_.size() - 1; - results_[idx].resize(eventsIds.size()); - results_[idx].setLoadLevel(minVariation); SimulationResult result0; findOrLaunchLoadIncrease(loadIncrease, minVariation, minVariation, minVariation, marginCalculation->getAccuracy(), result0); - results_[idx].setPreScenariosLoadIncreaseResult(result0); - results_[idx].setStatus(result0.getStatus()); + const auto resultIt3 = results_.emplace(std::piecewise_construct, + std::forward_as_tuple(result0.getVariation()), + std::forward_as_tuple(result0, eventsIds.size())); + if (!resultIt3.second) { + throw std::runtime_error("Load increase result already added"); + } + LoadIncreaseResult& loadIncreaseResult3 = resultIt3.first->second; if (result0.getSuccess()) { toRun = std::queue(); toRun.push(task_t(minVariation, minVariation, eventsIds)); - LoadIncreaseResult liResultTmp; - liResultTmp.resize(events.size()); + LoadIncreaseResult liResultTmp(SimulationResult(), events.size()); findOrLaunchScenarios(baseJobsFile, events, toRun, liResultTmp); for (size_t i = 0; i < eventsIds.size(); ++i) { - results_[idx].getScenarioResult(i) = liResultTmp.getScenarioResult(eventsIds[i]); + loadIncreaseResult3.getScenarioResult(i) = liResultTmp.getScenarioResult(eventsIds[i]); } // analyze results - for (std::vector::const_iterator it = results_[idx].begin(), - itEnd = results_[idx].end(); it != itEnd; ++it) { + for (std::vector::const_iterator it = loadIncreaseResult3.getScenariosResults().begin(), + itEnd = loadIncreaseResult3.getScenariosResults().end(); it != itEnd; ++it) { TraceInfo(logTag_) << DYNAlgorithmsLog(ScenariosEnd, it->getUniqueScenarioId(), getStatusAsString(it->getStatus())) << Trace::endline; } } @@ -337,14 +338,15 @@ MarginCalculationLauncher::computeGlobalMargin(const boost::shared_ptr tolerance ) { double newVariation = round((minVariation + maxVariation)/2.); - results_.push_back(LoadIncreaseResult()); - size_t idx = results_.size() - 1; - results_[idx].resize(events.size()); - results_[idx].setLoadLevel(newVariation); SimulationResult result; findOrLaunchLoadIncrease(loadIncrease, newVariation, minVariation, maxVariation, tolerance, result); - results_[idx].setStatus(result.getStatus()); - results_[idx].setPreScenariosLoadIncreaseResult(result); + const auto resultIt = results_.emplace(std::piecewise_construct, + std::forward_as_tuple(result.getVariation()), + std::forward_as_tuple(result, events.size())); + if (!resultIt.second) { + throw std::runtime_error("Load increase result already added"); + } + LoadIncreaseResult& loadIncreaseResult = resultIt.first->second; // If at some point loadIncrease for 0. is launched and is not working no need to continue std::map::const_iterator itZero = loadIncreaseStatus_.find(0.); if (itZero != loadIncreaseStatus_.end() && !itZero->second.success) @@ -357,25 +359,26 @@ MarginCalculationLauncher::computeGlobalMargin(const boost::shared_ptr maximumVariationPassing[i]) { eventsIds.push_back(i); } else { - results_[idx].getScenarioResult(i).setScenarioId(events[i]->getId()); - results_[idx].getScenarioResult(i).setVariation(newVariation); - results_[idx].getScenarioResult(i).setSuccess(true); - results_[idx].getScenarioResult(i).setStatus(CONVERGENCE_STATUS); + loadIncreaseResult.getScenarioResult(i).setScenarioId(events[i]->getId()); + loadIncreaseResult.getScenarioResult(i).setVariation(newVariation); + loadIncreaseResult.getScenarioResult(i).setSuccess(true); + loadIncreaseResult.getScenarioResult(i).setStatus(CONVERGENCE_STATUS); } } findAllLevelsBetween(minVariation, maxVariation, tolerance, eventsIds, toRun); - findOrLaunchScenarios(baseJobsFile, events, toRun, results_[idx]); + findOrLaunchScenarios(baseJobsFile, events, toRun, loadIncreaseResult); // analyze results unsigned int nbSuccess = 0; size_t id = 0; - for (std::vector::const_iterator it = results_[idx].begin(), - itEnd = results_[idx].end(); it != itEnd; ++it, ++id) { + for (std::vector::const_iterator simulationResultIt = loadIncreaseResult.getScenariosResults().begin(); + simulationResultIt != loadIncreaseResult.getScenariosResults().end(); ++simulationResultIt, ++id) { if (newVariation < maximumVariationPassing[id] || DYN::doubleEquals(newVariation, maximumVariationPassing[id])) - TraceInfo(logTag_) << DYNAlgorithmsLog(ScenarioNotSimulated, it->getUniqueScenarioId()) << Trace::endline; + TraceInfo(logTag_) << DYNAlgorithmsLog(ScenarioNotSimulated, simulationResultIt->getUniqueScenarioId()) << Trace::endline; else - TraceInfo(logTag_) << DYNAlgorithmsLog(ScenariosEnd, it->getUniqueScenarioId(), getStatusAsString(it->getStatus())) << Trace::endline; - if (it->getStatus() == CONVERGENCE_STATUS || newVariation < maximumVariationPassing[id] || + TraceInfo(logTag_) << DYNAlgorithmsLog(ScenariosEnd, + simulationResultIt->getUniqueScenarioId(), getStatusAsString(simulationResultIt->getStatus())) << Trace::endline; + if (simulationResultIt->getStatus() == CONVERGENCE_STATUS || newVariation < maximumVariationPassing[id] || DYN::doubleEquals(newVariation, maximumVariationPassing[id])) { // event OK nbSuccess++; if (newVariation > maximumVariationPassing[id]) @@ -443,14 +446,15 @@ MarginCalculationLauncher::computeLocalMargin(const boost::shared_ptr& eventsId = task.ids_; double newVariation = round((task.minVariation_ + task.maxVariation_)/2.); - results_.push_back(LoadIncreaseResult()); - size_t idx = results_.size() - 1; - results_[idx].resize(eventsId.size()); - results_[idx].setLoadLevel(newVariation); SimulationResult result; findOrLaunchLoadIncrease(loadIncrease, newVariation, minVariation, maxVariation, tolerance, result); - results_[idx].setPreScenariosLoadIncreaseResult(result); - results_[idx].setStatus(result.getStatus()); + const auto resultIt = results_.emplace(std::piecewise_construct, + std::forward_as_tuple(result.getVariation()), + std::forward_as_tuple(result, eventsId.size())); + if (!resultIt.second) { + throw std::runtime_error("Load increase result already added"); + } + LoadIncreaseResult& loadIncreaseResult = resultIt.first->second; // If at some point loadIncrease for 0. is launched and is not working no need to continue std::map::const_iterator itZero = loadIncreaseStatus_.find(0.); if (itZero != loadIncreaseStatus_.end() && !itZero->second.success) { @@ -462,18 +466,17 @@ MarginCalculationLauncher::computeLocalMargin(const boost::shared_ptr tolerance ) { @@ -869,20 +872,21 @@ MarginCalculationLauncher::createOutputs(std::map& map std::map bestResults; std::map worstResults; - for (std::vector::const_iterator itLoadIncreaseResult = results_.begin(); - itLoadIncreaseResult != results_.end(); ++itLoadIncreaseResult) { - double loadLevel = itLoadIncreaseResult->getLoadLevel(); - for (std::vector::const_iterator itSimulationResult = itLoadIncreaseResult->begin(); - itSimulationResult != itLoadIncreaseResult->end(); ++itSimulationResult) { - std::string scenarioId = itSimulationResult->getScenarioId(); - if (itSimulationResult->getSuccess()) { + + for (auto loadIncreaseResultIt = results_.begin(); loadIncreaseResultIt != results_.end(); ++loadIncreaseResultIt) { + const LoadIncreaseResult& loadIncreaseResult = loadIncreaseResultIt->second; + const double loadLevel = loadIncreaseResult.getPreScenariosLoadIncreaseResult().getVariation(); + + for (const SimulationResult& scenarioResult : loadIncreaseResult.getScenariosResults()) { + std::string scenarioId = scenarioResult.getScenarioId(); + if (scenarioResult.getSuccess()) { std::map::iterator itBest = bestResults.find(scenarioId); if (itBest == bestResults.end() || (loadLevel > itBest->second.getVariation())) - bestResults[scenarioId] = *itSimulationResult; + bestResults[scenarioId] = scenarioResult; } else { std::map::iterator itWorst = worstResults.find(scenarioId); if (itWorst == worstResults.end() || loadLevel < itWorst->second.getVariation()) - worstResults[scenarioId] = *itSimulationResult; + worstResults[scenarioId] = scenarioResult; } } } diff --git a/sources/Launcher/DYNMarginCalculationLauncher.h b/sources/Launcher/DYNMarginCalculationLauncher.h index 278eaf61..6698815f 100644 --- a/sources/Launcher/DYNMarginCalculationLauncher.h +++ b/sources/Launcher/DYNMarginCalculationLauncher.h @@ -270,7 +270,6 @@ class MarginCalculationLauncher : public RobustnessAnalysisLauncher { */ static std::string computeLoadIncreaseScenarioId(double variation); - private: /** * @brief double comparison with tolerance */ @@ -310,7 +309,7 @@ class MarginCalculationLauncher : public RobustnessAnalysisLauncher { std::map scenarioStatus_; ///< Map of scenario status by variation - std::vector results_; ///< results of the systematic analysis + std::map results_; ///< results of the systematic analysis std::map inputsByIIDM_; ///< For scenarios, the contexts to use, by IIDM file double tLoadIncrease_; ///< maximum stop time for the load increase part double tScenario_; ///< stop time for the scenario part