From 79fd321323dcf351d3ac21732e39c046d701007d Mon Sep 17 00:00:00 2001 From: Philip Top Date: Wed, 27 May 2026 18:31:31 -0700 Subject: [PATCH 1/5] align sundials interfaces to the style guide --- src/griddyn/solvers/ArkodeInterface.cpp | 48 +++++++++--------- src/griddyn/solvers/ArkodeInterface.h | 8 +-- src/griddyn/solvers/CvodeInterface.cpp | 48 +++++++++--------- src/griddyn/solvers/CvodeInterface.h | 8 +-- src/griddyn/solvers/IdaInterface.cpp | 50 +++++++++---------- src/griddyn/solvers/IdaInterface.h | 8 +-- src/griddyn/solvers/KinsolInterface.cpp | 38 +++++++------- src/griddyn/solvers/KinsolInterface.h | 8 +-- src/griddyn/solvers/SolverInterface.cpp | 4 +- src/griddyn/solvers/SundialsInterface.cpp | 8 +-- src/griddyn/solvers/SundialsMatrixData.cpp | 6 +-- src/griddyn/solvers/SundialsMatrixData.h | 18 +++---- .../solvers/sundialsMatrixDataDense.cpp | 16 +++--- .../sundialsMatrixDataSparseColumn.cpp | 20 ++++---- .../solvers/sundialsMatrixDataSparseRow.cpp | 20 ++++---- 15 files changed, 154 insertions(+), 154 deletions(-) diff --git a/src/griddyn/solvers/ArkodeInterface.cpp b/src/griddyn/solvers/ArkodeInterface.cpp index 118e7fb9e..5aa31e477 100644 --- a/src/griddyn/solvers/ArkodeInterface.cpp +++ b/src/griddyn/solvers/ArkodeInterface.cpp @@ -41,7 +41,7 @@ int arkodeJac(sunrealtype time, int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data); -arkodeInterface::arkodeInterface(const std::string& objName): SundialsInterface(objName) +ArkodeInterface::ArkodeInterface(const std::string& objName): SundialsInterface(objName) { mode.dynamic = true; mode.differential = true; @@ -49,7 +49,7 @@ arkodeInterface::arkodeInterface(const std::string& objName): SundialsInterface( max_iterations = 1500; } -arkodeInterface::arkodeInterface(GridDynSimulation* gds, const solverMode& sMode): +ArkodeInterface::ArkodeInterface(GridDynSimulation* gds, const solverMode& sMode): SundialsInterface(gds, sMode) { mode.dynamic = true; @@ -58,7 +58,7 @@ arkodeInterface::arkodeInterface(GridDynSimulation* gds, const solverMode& sMode max_iterations = 1500; } -arkodeInterface::~arkodeInterface() +ArkodeInterface::~ArkodeInterface() { // clear variables for CVode to use if (flags[initialized_flag]) { @@ -66,17 +66,17 @@ arkodeInterface::~arkodeInterface() } } -std::unique_ptr arkodeInterface::clone(bool fullCopy) const +std::unique_ptr ArkodeInterface::clone(bool fullCopy) const { - std::unique_ptr si = std::make_unique(); - arkodeInterface::cloneTo(si.get(), fullCopy); + std::unique_ptr si = std::make_unique(); + ArkodeInterface::cloneTo(si.get(), fullCopy); return si; } -void arkodeInterface::cloneTo(SolverInterface* si, bool fullCopy) const +void ArkodeInterface::cloneTo(SolverInterface* si, bool fullCopy) const { SundialsInterface::cloneTo(si, fullCopy); - auto ai = dynamic_cast(si); + auto ai = dynamic_cast(si); if (ai == nullptr) { return; } @@ -85,7 +85,7 @@ void arkodeInterface::cloneTo(SolverInterface* si, bool fullCopy) const ai->step = step; } -void arkodeInterface::allocate(count_t stateCount, count_t numRoots) +void ArkodeInterface::allocate(count_t stateCount, count_t numRoots) { // load the vectors if (stateCount == svsize) { @@ -110,14 +110,14 @@ void arkodeInterface::allocate(count_t stateCount, count_t numRoots) SundialsInterface::allocate(stateCount, numRoots); } -void arkodeInterface::setMaxNonZeros(count_t nonZeroCount) +void ArkodeInterface::setMaxNonZeros(count_t nonZeroCount) { maxNNZ = nonZeroCount; a1.reserve(nonZeroCount); a1.clear(); } -void arkodeInterface::set(std::string_view param, std::string_view val) +void ArkodeInterface::set(std::string_view param, std::string_view val) { if (param.empty()) { } else { @@ -125,7 +125,7 @@ void arkodeInterface::set(std::string_view param, std::string_view val) } } -void arkodeInterface::set(std::string_view param, double val) +void ArkodeInterface::set(std::string_view param, double val) { bool checkStepUpdate = false; if (param == "step") { @@ -160,7 +160,7 @@ void arkodeInterface::set(std::string_view param, double val) } } -double arkodeInterface::get(std::string_view param) const +double ArkodeInterface::get(std::string_view param) const { int val = -1; if ((param == "resevals") || (param == "iterationcount")) { @@ -181,7 +181,7 @@ double arkodeInterface::get(std::string_view param) const } // output solver stats -void arkodeInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const +void ArkodeInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const { if (!flags[initialized_flag]) { return; @@ -240,7 +240,7 @@ void arkodeInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const } } -void arkodeInterface::logErrorWeights(PrintLevel logLevel) const +void ArkodeInterface::logErrorWeights(PrintLevel logLevel) const { N_Vector eweight = NVECTOR_NEW(use_omp, svsize); N_Vector ele = NVECTOR_NEW(use_omp, svsize); @@ -293,7 +293,7 @@ static const std::map arkodeRetCodes{ }; -void arkodeInterface::initialize(coreTime time0) +void ArkodeInterface::initialize(coreTime time0) { if (!flags[allocated_flag]) { throw(InvalidSolverOperation()); @@ -375,12 +375,12 @@ void arkodeInterface::initialize(coreTime time0) flags.set(initialized_flag); } -void arkodeInterface::sparseReInit(SparseReinitMode sparseReinitMode) +void ArkodeInterface::sparseReInit(SparseReinitMode sparseReinitMode) { kluReInit(sparseReinitMode); } -void arkodeInterface::setRootFinding(count_t numRoots) +void ArkodeInterface::setRootFinding(count_t numRoots) { if (numRoots != static_cast(rootsfound.size())) { rootsfound.resize(numRoots); @@ -390,7 +390,7 @@ void arkodeInterface::setRootFinding(count_t numRoots) checkFlag(&retval, "ARKodeRootInit", 1); } -void arkodeInterface::getCurrentData() +void ArkodeInterface::getCurrentData() { /* int retval = CVodeGetConsistentIC(solverMem, state, deriv); @@ -401,7 +401,7 @@ return(retval); */ } -int arkodeInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) +int ArkodeInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) { assert(rootCount == m_gds->rootSize(mode)); ++solverCallCount; @@ -418,13 +418,13 @@ int arkodeInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) return retval; } -void arkodeInterface::getRoots() +void ArkodeInterface::getRoots() { int ret = ARKodeGetRootInfo(solverMem, rootsfound.data()); checkFlag(&ret, "ARKodeGetRootInfo", 1); } -void arkodeInterface::loadMaskElements() +void ArkodeInterface::loadMaskElements() { std::vector mStates(svsize, 0.0); m_gds->getVoltageStates(mStates.data(), mode); @@ -440,7 +440,7 @@ void arkodeInterface::loadMaskElements() // CVode C Functions int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_data) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(user_data); sd->funcCallCount++; if (sd->mode.pairedOffsetIndex != kNullLocation) { int ret = sd->m_gds->dynAlgebraicSolve(time, @@ -480,7 +480,7 @@ int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_ int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(user_data); sd->m_gds->rootFindingFunction( time, NVECTOR_DATA(sd->use_omp, state), sd->derivData(), gout, sd->mode); diff --git a/src/griddyn/solvers/ArkodeInterface.h b/src/griddyn/solvers/ArkodeInterface.h index 18f6ac3b6..be008bb61 100644 --- a/src/griddyn/solvers/ArkodeInterface.h +++ b/src/griddyn/solvers/ArkodeInterface.h @@ -14,7 +14,7 @@ namespace griddyn::solvers { /** @brief SolverInterface interfacing to the SUNDIALS arkode solver */ -class arkodeInterface: public SundialsInterface { +class ArkodeInterface: public SundialsInterface { public: using SundialsInterface::set; count_t icCount = @@ -30,14 +30,14 @@ class arkodeInterface: public SundialsInterface { public: /** @brief constructor*/ - explicit arkodeInterface(const std::string& objName = "arkode"); + explicit ArkodeInterface(const std::string& objName = "arkode"); /** @brief alternate constructor @param[in] gds the GridDynSimulation object to connect to @param[in] sMode the solverMode to solve For */ - arkodeInterface(GridDynSimulation* gds, const solverMode& sMode); + ArkodeInterface(GridDynSimulation* gds, const solverMode& sMode); /** @brief destructor*/ - virtual ~arkodeInterface(); + virtual ~ArkodeInterface(); virtual std::unique_ptr clone(bool fullCopy = false) const override; diff --git a/src/griddyn/solvers/CvodeInterface.cpp b/src/griddyn/solvers/CvodeInterface.cpp index d985871b7..78cd2545c 100644 --- a/src/griddyn/solvers/CvodeInterface.cpp +++ b/src/griddyn/solvers/CvodeInterface.cpp @@ -42,7 +42,7 @@ int cvodeJac(sunrealtype time, int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data); -cvodeInterface::cvodeInterface(const std::string& objName): SundialsInterface(objName) +CvodeInterface::CvodeInterface(const std::string& objName): SundialsInterface(objName) { mode.dynamic = true; mode.differential = true; @@ -50,7 +50,7 @@ cvodeInterface::cvodeInterface(const std::string& objName): SundialsInterface(ob max_iterations = 1500; } -cvodeInterface::cvodeInterface(GridDynSimulation* gds, const solverMode& sMode): +CvodeInterface::CvodeInterface(GridDynSimulation* gds, const solverMode& sMode): SundialsInterface(gds, sMode) { mode.dynamic = true; @@ -59,7 +59,7 @@ cvodeInterface::cvodeInterface(GridDynSimulation* gds, const solverMode& sMode): max_iterations = 1500; } -cvodeInterface::~cvodeInterface() +CvodeInterface::~CvodeInterface() { // clear variables for CVode to use if (flags[initialized_flag]) { @@ -67,17 +67,17 @@ cvodeInterface::~cvodeInterface() } } -std::unique_ptr cvodeInterface::clone(bool fullCopy) const +std::unique_ptr CvodeInterface::clone(bool fullCopy) const { - std::unique_ptr si = std::make_unique(); - cvodeInterface::cloneTo(si.get(), fullCopy); + std::unique_ptr si = std::make_unique(); + CvodeInterface::cloneTo(si.get(), fullCopy); return si; } -void cvodeInterface::cloneTo(SolverInterface* si, bool fullCopy) const +void CvodeInterface::cloneTo(SolverInterface* si, bool fullCopy) const { SundialsInterface::cloneTo(si, fullCopy); - auto ai = dynamic_cast(si); + auto ai = dynamic_cast(si); if (ai == nullptr) { return; } @@ -86,7 +86,7 @@ void cvodeInterface::cloneTo(SolverInterface* si, bool fullCopy) const ai->step = step; } -void cvodeInterface::allocate(count_t stateCount, count_t numRoots) +void CvodeInterface::allocate(count_t stateCount, count_t numRoots) { // load the vectors if (stateCount == svsize) { @@ -110,14 +110,14 @@ void cvodeInterface::allocate(count_t stateCount, count_t numRoots) SundialsInterface::allocate(stateCount, numRoots); } -void cvodeInterface::setMaxNonZeros(count_t nonZeroCount) +void CvodeInterface::setMaxNonZeros(count_t nonZeroCount) { maxNNZ = nonZeroCount; a1.reserve(nonZeroCount); a1.clear(); } -void cvodeInterface::set(std::string_view param, std::string_view val) +void CvodeInterface::set(std::string_view param, std::string_view val) { if (param.empty() || param[0] == '#') { } else { @@ -125,7 +125,7 @@ void cvodeInterface::set(std::string_view param, std::string_view val) } } -void cvodeInterface::set(std::string_view param, double val) +void CvodeInterface::set(std::string_view param, double val) { bool checkStepUpdate = false; if (param == "step") { @@ -159,7 +159,7 @@ void cvodeInterface::set(std::string_view param, double val) } } -double cvodeInterface::get(std::string_view param) const +double CvodeInterface::get(std::string_view param) const { int val = -1; if ((param == "resevals") || (param == "iterationcount")) { @@ -180,7 +180,7 @@ double cvodeInterface::get(std::string_view param) const } // output solver stats -void cvodeInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const +void CvodeInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const { if (!flags[initialized_flag]) { return; @@ -248,7 +248,7 @@ void cvodeInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const } } -void cvodeInterface::logErrorWeights(PrintLevel logLevel) const +void CvodeInterface::logErrorWeights(PrintLevel logLevel) const { N_Vector eweight = NVECTOR_NEW(use_omp, svsize); N_Vector ele = NVECTOR_NEW(use_omp, svsize); @@ -272,7 +272,7 @@ void cvodeInterface::logErrorWeights(PrintLevel logLevel) const NVECTOR_DESTROY(use_omp, ele); } -void cvodeInterface::initialize(coreTime time0) +void CvodeInterface::initialize(coreTime time0) { if (!flags[allocated_flag]) { throw(InvalidSolverOperation()); @@ -356,12 +356,12 @@ void cvodeInterface::initialize(coreTime time0) flags.set(initialized_flag); } -void cvodeInterface::sparseReInit(SparseReinitMode reInitMode) +void CvodeInterface::sparseReInit(SparseReinitMode reInitMode) { kluReInit(reInitMode); } -void cvodeInterface::setRootFinding(count_t numRoots) +void CvodeInterface::setRootFinding(count_t numRoots) { if (numRoots != static_cast(rootsfound.size())) { rootsfound.resize(numRoots); @@ -371,7 +371,7 @@ void cvodeInterface::setRootFinding(count_t numRoots) checkFlag(&retval, "CVodeRootInit", 1); } -void cvodeInterface::getCurrentData() +void CvodeInterface::getCurrentData() { /* int retval = CVodeGetConsistentIC(solverMem, state, deriv); @@ -382,7 +382,7 @@ if (checkFlag(&retval, "CVodeGetConsistentIC", 1)) */ } -int cvodeInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) +int CvodeInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) { assert(rootCount == m_gds->rootSize(mode)); ++solverCallCount; @@ -403,13 +403,13 @@ int cvodeInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) return retval; } -void cvodeInterface::getRoots() +void CvodeInterface::getRoots() { int ret = CVodeGetRootInfo(solverMem, rootsfound.data()); checkFlag(&ret, "CVodeGetRootInfo", 1); } -void cvodeInterface::loadMaskElements() +void CvodeInterface::loadMaskElements() { std::vector mStates(svsize, 0.0); m_gds->getVoltageStates(mStates.data(), mode); @@ -425,7 +425,7 @@ void cvodeInterface::loadMaskElements() // CVode C Functions int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_data) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(user_data); sd->funcCallCount++; if (sd->mode.pairedOffsetIndex != kNullLocation) { int ret = sd->m_gds->dynAlgebraicSolve(time, @@ -466,7 +466,7 @@ int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_d int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(user_data); sd->m_gds->rootFindingFunction( time, NVECTOR_DATA(sd->use_omp, state), sd->derivData(), gout, sd->mode); diff --git a/src/griddyn/solvers/CvodeInterface.h b/src/griddyn/solvers/CvodeInterface.h index 62ddfb736..e611466af 100644 --- a/src/griddyn/solvers/CvodeInterface.h +++ b/src/griddyn/solvers/CvodeInterface.h @@ -14,7 +14,7 @@ namespace griddyn::solvers { /** @brief SolverInterface interfacing to the SUNDIALS cvode solver */ -class cvodeInterface: public SundialsInterface { +class CvodeInterface: public SundialsInterface { public: using SundialsInterface::set; count_t icCount = 0; //!< total number of initial condition calls @@ -28,14 +28,14 @@ class cvodeInterface: public SundialsInterface { public: /** @brief constructor*/ - explicit cvodeInterface(const std::string& objName = "cvode"); + explicit CvodeInterface(const std::string& objName = "cvode"); /** @brief alternate constructor @param[in] gds the GridDynSimulation object to connect to @param[in] sMode the solverMode to solve For */ - cvodeInterface(GridDynSimulation* gds, const solverMode& sMode); + CvodeInterface(GridDynSimulation* gds, const solverMode& sMode); /** @brief destructor*/ - virtual ~cvodeInterface(); + virtual ~CvodeInterface(); virtual std::unique_ptr clone(bool fullCopy = false) const override; diff --git a/src/griddyn/solvers/IdaInterface.cpp b/src/griddyn/solvers/IdaInterface.cpp index 405af91d3..3bc8255c2 100644 --- a/src/griddyn/solvers/IdaInterface.cpp +++ b/src/griddyn/solvers/IdaInterface.cpp @@ -52,18 +52,18 @@ int idaRootFunc(sunrealtype time, sunrealtype* gout, void* user_data); -idaInterface::idaInterface(const std::string& objName): SundialsInterface(objName) +IdaInterface::IdaInterface(const std::string& objName): SundialsInterface(objName) { max_iterations = 1500; } -idaInterface::idaInterface(GridDynSimulation* gds, const solverMode& sMode): +IdaInterface::IdaInterface(GridDynSimulation* gds, const solverMode& sMode): SundialsInterface(gds, sMode) { max_iterations = 1500; } -idaInterface::~idaInterface() +IdaInterface::~IdaInterface() { // clear variables for IDA to use if (flags[initialized_flag]) { @@ -71,23 +71,23 @@ idaInterface::~idaInterface() } } -std::unique_ptr idaInterface::clone(bool fullCopy) const +std::unique_ptr IdaInterface::clone(bool fullCopy) const { - std::unique_ptr si = std::make_unique(); - idaInterface::cloneTo(si.get(), fullCopy); + std::unique_ptr si = std::make_unique(); + IdaInterface::cloneTo(si.get(), fullCopy); return si; } -void idaInterface::cloneTo(SolverInterface* si, bool fullCopy) const +void IdaInterface::cloneTo(SolverInterface* si, bool fullCopy) const { SundialsInterface::cloneTo(si, fullCopy); - auto ai = dynamic_cast(si); + auto ai = dynamic_cast(si); if (ai == nullptr) { return; } } -void idaInterface::allocate(count_t stateCount, count_t numRoots) +void IdaInterface::allocate(count_t stateCount, count_t numRoots) { // load the vectors if (stateCount == svsize) { @@ -111,7 +111,7 @@ void idaInterface::allocate(count_t stateCount, count_t numRoots) SundialsInterface::allocate(stateCount, numRoots); } -void idaInterface::setMaxNonZeros(count_t nonZeros) +void IdaInterface::setMaxNonZeros(count_t nonZeros) { maxNNZ = nonZeros; jacCallCount = 0; @@ -119,7 +119,7 @@ void idaInterface::setMaxNonZeros(count_t nonZeros) a1.clear(); } -void idaInterface::set(std::string_view param, double val) +void IdaInterface::set(std::string_view param, double val) { if (param == "maxiterations") { max_iterations = static_cast(val); @@ -130,7 +130,7 @@ void idaInterface::set(std::string_view param, double val) } } -double idaInterface::get(std::string_view param) const +double IdaInterface::get(std::string_view param) const { long int val = -1; if ((param == "resevals") || (param == "iterationcount")) { @@ -149,7 +149,7 @@ double idaInterface::get(std::string_view param) const } // output solver stats -void idaInterface::logSolverStats(PrintLevel logLevel, bool iconly) const +void IdaInterface::logSolverStats(PrintLevel logLevel, bool iconly) const { if (!flags[initialized_flag]) { return; @@ -232,7 +232,7 @@ void idaInterface::logSolverStats(PrintLevel logLevel, bool iconly) const } } -void idaInterface::logErrorWeights(PrintLevel logLevel) const +void IdaInterface::logErrorWeights(PrintLevel logLevel) const { N_Vector eweight = NVECTOR_NEW(use_omp, svsize); N_Vector ele = NVECTOR_NEW(use_omp, svsize); @@ -255,7 +255,7 @@ void idaInterface::logErrorWeights(PrintLevel logLevel) const NVECTOR_DESTROY(use_omp, ele); } -void idaInterface::initialize(coreTime t0) +void IdaInterface::initialize(coreTime t0) { if (!flags[allocated_flag]) { throw(InvalidSolverOperation()); @@ -333,12 +333,12 @@ void idaInterface::initialize(coreTime t0) flags.set(initialized_flag); } -void idaInterface::sparseReInit(SparseReinitMode sparseReInitMode) +void IdaInterface::sparseReInit(SparseReinitMode sparseReInitMode) { kluReInit(sparseReInitMode); } -void idaInterface::setRootFinding(count_t numRoots) +void IdaInterface::setRootFinding(count_t numRoots) { if (numRoots != static_cast(rootsfound.size())) { rootsfound.resize(numRoots); @@ -350,7 +350,7 @@ void idaInterface::setRootFinding(count_t numRoots) #define SHOW_MISSING_ELEMENTS 0 -int idaInterface::calcIC(coreTime t0, coreTime tstep0, IcModes initCondMode, bool constraints) +int IdaInterface::calcIC(coreTime t0, coreTime tstep0, IcModes initCondMode, bool constraints) { int retval; ++icCount; @@ -444,13 +444,13 @@ int idaInterface::calcIC(coreTime t0, coreTime tstep0, IcModes initCondMode, boo return FUNCTION_EXECUTION_SUCCESS; } -void idaInterface::getCurrentData() +void IdaInterface::getCurrentData() { int retval = IDAGetConsistentIC(solverMem, state, dstate_dt); checkFlag(&retval, "IDAGetConsistentIC", 1); } -int idaInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) +int IdaInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) { assert(rootCount == m_gds->rootSize(mode)); ++solverCallCount; @@ -478,13 +478,13 @@ int idaInterface::solve(coreTime tStop, coreTime& tReturn, StepMode stepMode) return retval; } -void idaInterface::getRoots() +void IdaInterface::getRoots() { int ret = IDAGetRootInfo(solverMem, rootsfound.data()); checkFlag(&ret, "IDAGetRootInfo", 1); } -void idaInterface::setConstraints() +void IdaInterface::setConstraints() { if (m_gds->hasConstraints()) { N_VConst(ZERO, consData); @@ -493,7 +493,7 @@ void idaInterface::setConstraints() } } -void idaInterface::loadMaskElements() +void IdaInterface::loadMaskElements() { std::vector mStates(svsize, 0.0); m_gds->getVoltageStates(mStates.data(), mode); @@ -509,7 +509,7 @@ void idaInterface::loadMaskElements() // IDA C Functions int idaFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, N_Vector resid, void* user_data) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(user_data); // printf("time=%f\n", time); int ret = sd->m_gds->residualFunction(time, NVECTOR_DATA(sd->use_omp, state), @@ -559,7 +559,7 @@ int idaRootFunc(sunrealtype time, sunrealtype* gout, void* user_data) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(user_data); sd->m_gds->rootFindingFunction(time, NVECTOR_DATA(sd->use_omp, state), NVECTOR_DATA(sd->use_omp, dstate_dt), diff --git a/src/griddyn/solvers/IdaInterface.h b/src/griddyn/solvers/IdaInterface.h index e0d1ac65d..7c33ef6ea 100644 --- a/src/griddyn/solvers/IdaInterface.h +++ b/src/griddyn/solvers/IdaInterface.h @@ -14,7 +14,7 @@ namespace griddyn::solvers { /** @brief SolverInterface interfacing to the SUNDIALS IDA solver */ -class idaInterface: public SundialsInterface { +class IdaInterface: public SundialsInterface { public: using SundialsInterface::set; count_t icCount = 0; //!< the number of times the initical condition function was called @@ -25,14 +25,14 @@ class idaInterface: public SundialsInterface { std::vector tempState; //!< temporary holding location for a state vector public: /** @brief constructor*/ - explicit idaInterface(const std::string& objName = "ida"); + explicit IdaInterface(const std::string& objName = "ida"); /** @brief alternate constructor @param[in] gds the GridDynSimulation object to connect to @param[in] sMode the solverMode to solve For */ - idaInterface(GridDynSimulation* gds, const solverMode& sMode); + IdaInterface(GridDynSimulation* gds, const solverMode& sMode); /** @brief destructor*/ - ~idaInterface(); + ~IdaInterface(); virtual std::unique_ptr clone(bool fullCopy = false) const override; diff --git a/src/griddyn/solvers/KinsolInterface.cpp b/src/griddyn/solvers/KinsolInterface.cpp index 9bd684289..8ee331767 100644 --- a/src/griddyn/solvers/KinsolInterface.cpp +++ b/src/griddyn/solvers/KinsolInterface.cpp @@ -45,7 +45,7 @@ int kinsolJac(N_Vector state, // int kinsolAlgJacDense (long int N, N_Vector u, N_Vector f, DlsMat J, void *user_data, // N_Vector tmp1, N_Vector tmp2); -kinsolInterface::kinsolInterface(const std::string& objName): SundialsInterface(objName) +KinsolInterface::KinsolInterface(const std::string& objName): SundialsInterface(objName) { tolerance = 1e-8; mode.algebraic = true; @@ -53,7 +53,7 @@ kinsolInterface::kinsolInterface(const std::string& objName): SundialsInterface( max_iterations = 50; } -kinsolInterface::kinsolInterface(GridDynSimulation* gds, const solverMode& sMode): +KinsolInterface::KinsolInterface(GridDynSimulation* gds, const solverMode& sMode): SundialsInterface(gds, sMode) { tolerance = 1e-8; @@ -62,7 +62,7 @@ kinsolInterface::kinsolInterface(GridDynSimulation* gds, const solverMode& sMode max_iterations = 50; } -kinsolInterface::~kinsolInterface() +KinsolInterface::~KinsolInterface() { // clear the memory, the SundialsInterface destructor will clear the rest if (flags[initialized_flag]) { @@ -70,23 +70,23 @@ kinsolInterface::~kinsolInterface() } } -std::unique_ptr kinsolInterface::clone(bool fullCopy) const +std::unique_ptr KinsolInterface::clone(bool fullCopy) const { - std::unique_ptr si = std::make_unique(); - kinsolInterface::cloneTo(si.get(), fullCopy); + std::unique_ptr si = std::make_unique(); + KinsolInterface::cloneTo(si.get(), fullCopy); return si; } -void kinsolInterface::cloneTo(SolverInterface* si, bool fullCopy) const +void KinsolInterface::cloneTo(SolverInterface* si, bool fullCopy) const { SundialsInterface::cloneTo(si, fullCopy); - auto* ai = dynamic_cast(si); + auto* ai = dynamic_cast(si); if (ai == nullptr) { return; } } -void kinsolInterface::allocate(count_t stateCount, count_t /*numRoots*/) +void KinsolInterface::allocate(count_t stateCount, count_t /*numRoots*/) { // load the vectors if (stateCount == svsize) { @@ -103,7 +103,7 @@ void kinsolInterface::allocate(count_t stateCount, count_t /*numRoots*/) } // output solver stats -void kinsolInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const +void KinsolInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const { if (!flags[initialized_flag]) { return; @@ -140,7 +140,7 @@ void kinsolInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const } } -void kinsolInterface::initialize(coreTime /*t0*/) +void KinsolInterface::initialize(coreTime /*t0*/) { if (!flags[allocated_flag]) { throw(InvalidSolverOperation()); @@ -222,12 +222,12 @@ void kinsolInterface::initialize(coreTime /*t0*/) flags.set(initialized_flag); } -void kinsolInterface::sparseReInit(SparseReinitMode sparseReinitMode) +void KinsolInterface::sparseReInit(SparseReinitMode sparseReinitMode) { kluReInit(sparseReinitMode); } -void kinsolInterface::set(std::string_view param, std::string_view val) +void KinsolInterface::set(std::string_view param, std::string_view val) { if (param.empty()) { } else { @@ -235,7 +235,7 @@ void kinsolInterface::set(std::string_view param, std::string_view val) } } -void kinsolInterface::set(std::string_view param, double val) +void KinsolInterface::set(std::string_view param, double val) { if (param.empty()) { } else if (param == "maxiterations") { @@ -247,7 +247,7 @@ void kinsolInterface::set(std::string_view param, double val) } } -double kinsolInterface::get(std::string_view param) const +double KinsolInterface::get(std::string_view param) const { long int val = -1; if (param == "jac calls") { @@ -278,7 +278,7 @@ double kinsolInterface::get(std::string_view param) const // #define KIN_LINESEARCH 1 // #define KIN_PICARD 2 // #define KIN_FP 3 -int kinsolInterface::solve(coreTime tStop, coreTime& tReturn, StepMode /*mode*/) +int KinsolInterface::solve(coreTime tStop, coreTime& tReturn, StepMode /*mode*/) { // check if the multiple data sets are in use and if we should toggle the data to use solveTime = tStop; @@ -326,7 +326,7 @@ int kinsolInterface::solve(coreTime tStop, coreTime& tReturn, StepMode /*mode*/) return retval; } -void kinsolInterface::setConstraints() +void KinsolInterface::setConstraints() { if (m_gds->hasConstraints()) { N_VConst(ZERO, consData); @@ -340,7 +340,7 @@ void kinsolInterface::setConstraints() int kinsolFunc(N_Vector state, N_Vector resid, void* user_data) { - auto* sd = static_cast(user_data); + auto* sd = static_cast(user_data); sd->funcCallCount++; #if MEASURE_TIMINGS > 0 auto start_t = std::chrono::high_resolution_clock::now(); @@ -404,7 +404,7 @@ int kinsolJac(N_Vector state, N_Vector tmp1, N_Vector tmp2) { - auto* sd = static_cast(user_data); + auto* sd = static_cast(user_data); return sundialsJac(sd->solveTime, 0, state, nullptr, J, user_data, tmp1, tmp2); } diff --git a/src/griddyn/solvers/KinsolInterface.h b/src/griddyn/solvers/KinsolInterface.h index 443f005a7..d43f50399 100644 --- a/src/griddyn/solvers/KinsolInterface.h +++ b/src/griddyn/solvers/KinsolInterface.h @@ -13,19 +13,19 @@ namespace griddyn::solvers { /** @brief SolverInterface interfacing to the SUNDIALS kinsol solver */ -class kinsolInterface: public SundialsInterface { +class KinsolInterface: public SundialsInterface { public: using SundialsInterface::set; /** @brief constructor*/ - explicit kinsolInterface(const std::string& objName = "kinsol"); + explicit KinsolInterface(const std::string& objName = "kinsol"); /** @brief constructor loading the SolverInterface structure* @param[in] gds the GridDynSimulation to link with @param[in] sMode the solverMode for the solver */ - kinsolInterface(GridDynSimulation* gds, const solverMode& sMode); + KinsolInterface(GridDynSimulation* gds, const solverMode& sMode); /** @brief destructor */ - virtual ~kinsolInterface(); + virtual ~KinsolInterface(); virtual std::unique_ptr clone(bool fullCopy = false) const override; diff --git a/src/griddyn/solvers/SolverInterface.cpp b/src/griddyn/solvers/SolverInterface.cpp index 35bef4816..2b0501976 100644 --- a/src/griddyn/solvers/SolverInterface.cpp +++ b/src/griddyn/solvers/SolverInterface.cpp @@ -542,14 +542,14 @@ std::unique_ptr makeSolver(GridDynSimulation* gds, const solver if (isLocal(sMode)) { sd = std::make_unique(gds, sMode); } else if ((isAlgebraicOnly(sMode)) || (!isDynamic(sMode))) { - sd = std::make_unique(gds, sMode); + sd = std::make_unique(gds, sMode); if (sMode.offsetIndex == power_flow) { sd->setName("powerflow"); } else if (sMode.offsetIndex == dynamic_algebraic) { sd->setName("algebraic"); } } else if (isDAE(sMode)) { - sd = std::make_unique(gds, sMode); + sd = std::make_unique(gds, sMode); if (sMode.offsetIndex == dae) { sd->setName("dynamic"); } diff --git a/src/griddyn/solvers/SundialsInterface.cpp b/src/griddyn/solvers/SundialsInterface.cpp index 9e6c2f15b..1be3350c9 100644 --- a/src/griddyn/solvers/SundialsInterface.cpp +++ b/src/griddyn/solvers/SundialsInterface.cpp @@ -39,17 +39,17 @@ namespace griddyn::solvers { static void ensureSundialsFactories() { - static ChildClassFactory kinFactory( + static ChildClassFactory kinFactory( stringVec{"kinsol", "algebraic"}); - static ChildClassFactory idaFactory( + static ChildClassFactory idaFactory( stringVec{"ida", "dae", "dynamic"}); #ifdef GRIDDYN_ENABLE_CVODE - static ChildClassFactory cvodeFactory( + static ChildClassFactory cvodeFactory( stringVec{"cvode", "dyndiff", "differential"}); #endif #ifdef GRIDDYN_ENABLE_ARKODE - static ChildClassFactory arkodeFactory(stringVec{"arkode"}); + static ChildClassFactory arkodeFactory(stringVec{"arkode"}); #endif } diff --git a/src/griddyn/solvers/SundialsMatrixData.cpp b/src/griddyn/solvers/SundialsMatrixData.cpp index 35035a0f0..f801d669c 100644 --- a/src/griddyn/solvers/SundialsMatrixData.cpp +++ b/src/griddyn/solvers/SundialsMatrixData.cpp @@ -15,12 +15,12 @@ std::unique_ptr> makeSundialsMatrixData(SUNMatrix J) { switch (SUNMatGetID(J)) { case SUNMATRIX_DENSE: - return std::make_unique(J); + return std::make_unique(J); case SUNMATRIX_SPARSE: if (SM_SPARSETYPE_S(J) == CSR_MAT) { - return std::make_unique(J); + return std::make_unique(J); } else { - return std::make_unique(J); + return std::make_unique(J); } case SUNMATRIX_CUSTOM: default: diff --git a/src/griddyn/solvers/SundialsMatrixData.h b/src/griddyn/solvers/SundialsMatrixData.h index f437f5b0f..4cafe9335 100644 --- a/src/griddyn/solvers/SundialsMatrixData.h +++ b/src/griddyn/solvers/SundialsMatrixData.h @@ -15,16 +15,16 @@ namespace griddyn::solvers { /** @brief class implementing an matrixData wrapper around the SUNDIALS dense matrix*/ -class sundialsMatrixDataDense: public matrixData { +class SundialsMatrixDataDense: public matrixData { private: SUNMatrix J = nullptr; //!< the vector of tuples containing the data public: /** @brief compact constructor */ - sundialsMatrixDataDense() = default; + SundialsMatrixDataDense() = default; /** @brief alternate constructor defining the Dense matrix to fill @param[in] mat the dense SUNDIALS matrix*/ - explicit sundialsMatrixDataDense(SUNMatrix mat); + explicit SundialsMatrixDataDense(SUNMatrix mat); void clear() override; @@ -44,7 +44,7 @@ class sundialsMatrixDataDense: public matrixData { double at(index_t rowN, index_t colN) const override; }; -class sundialsMatrixDataSparseColumn: public matrixData { +class SundialsMatrixDataSparseColumn: public matrixData { private: SUNMatrix J = nullptr; //!< pointer to the sundials sparse matrix index_t ccol = 0; @@ -52,9 +52,9 @@ class sundialsMatrixDataSparseColumn: public matrixData { public: /** @brief compact constructor */ - sundialsMatrixDataSparseColumn() = default; + SundialsMatrixDataSparseColumn() = default; /** @brief alternate constructor defining the Sparse matrix to fill*/ - explicit sundialsMatrixDataSparseColumn(SUNMatrix mat); + explicit SundialsMatrixDataSparseColumn(SUNMatrix mat); void clear() override; @@ -79,7 +79,7 @@ class sundialsMatrixDataSparseColumn: public matrixData { }; /** @brief class implementing an matrixData wrapper around the SUNDIALS dense matrix*/ -class sundialsMatrixDataSparseRow: public matrixData { +class SundialsMatrixDataSparseRow: public matrixData { private: SUNMatrix J; //!< the vector of tuples containing the data index_t crow = 0; //!< the current row of access @@ -87,9 +87,9 @@ class sundialsMatrixDataSparseRow: public matrixData { public: /** @brief compact constructor */ - sundialsMatrixDataSparseRow() = default; + SundialsMatrixDataSparseRow() = default; /** @brief alternate constructor defining the Sparse matrix to fill*/ - explicit sundialsMatrixDataSparseRow(SUNMatrix mat); + explicit SundialsMatrixDataSparseRow(SUNMatrix mat); void clear() override; diff --git a/src/griddyn/solvers/sundialsMatrixDataDense.cpp b/src/griddyn/solvers/sundialsMatrixDataDense.cpp index 2a29e42c7..5ad8f5e8e 100644 --- a/src/griddyn/solvers/sundialsMatrixDataDense.cpp +++ b/src/griddyn/solvers/sundialsMatrixDataDense.cpp @@ -9,43 +9,43 @@ #include namespace griddyn::solvers { -sundialsMatrixDataDense::sundialsMatrixDataDense(SUNMatrix mat): +SundialsMatrixDataDense::SundialsMatrixDataDense(SUNMatrix mat): matrixData(static_cast(SM_ROWS_D(mat)), static_cast(SM_COLUMNS_D(mat))), J(mat) { } -void sundialsMatrixDataDense::clear() +void SundialsMatrixDataDense::clear() { SUNMatZero(J); } -void sundialsMatrixDataDense::assign(index_t X, index_t Y, double num) +void SundialsMatrixDataDense::assign(index_t X, index_t Y, double num) { SM_ELEMENT_D(J, X, Y) += num; } -void sundialsMatrixDataDense::setMatrix(SUNMatrix mat) +void SundialsMatrixDataDense::setMatrix(SUNMatrix mat) { J = mat; setRowLimit(static_cast(SM_ROWS_D(J))); setColLimit(static_cast(SM_COLUMNS_D(J))); } -count_t sundialsMatrixDataDense::size() const +count_t SundialsMatrixDataDense::size() const { return static_cast(SM_ROWS_D(J) * SM_COLUMNS_D(J)); } -count_t sundialsMatrixDataDense::capacity() const +count_t SundialsMatrixDataDense::capacity() const { return static_cast(SM_ROWS_D(J) * SM_COLUMNS_D(J)); } -matrixElement sundialsMatrixDataDense::element(index_t N) const +matrixElement SundialsMatrixDataDense::element(index_t N) const { return {N % static_cast(SM_COLUMNS_D(J)), N / static_cast(SM_COLUMNS_D(J)), SM_DATA_D(J)[N]}; } -double sundialsMatrixDataDense::at(index_t rowN, index_t colN) const +double SundialsMatrixDataDense::at(index_t rowN, index_t colN) const { return SM_ELEMENT_D(J, rowN, colN); } diff --git a/src/griddyn/solvers/sundialsMatrixDataSparseColumn.cpp b/src/griddyn/solvers/sundialsMatrixDataSparseColumn.cpp index 3f14bbbb4..fc7f730b5 100644 --- a/src/griddyn/solvers/sundialsMatrixDataSparseColumn.cpp +++ b/src/griddyn/solvers/sundialsMatrixDataSparseColumn.cpp @@ -9,18 +9,18 @@ #include namespace griddyn::solvers { -sundialsMatrixDataSparseColumn::sundialsMatrixDataSparseColumn(SUNMatrix mat): +SundialsMatrixDataSparseColumn::SundialsMatrixDataSparseColumn(SUNMatrix mat): matrixData(static_cast(SM_ROWS_S(mat)), static_cast(SM_COLUMNS_S(mat))), J(mat) { } -void sundialsMatrixDataSparseColumn::clear() +void SundialsMatrixDataSparseColumn::clear() { SUNMatZero(J); } -void sundialsMatrixDataSparseColumn::assign(index_t row, index_t col, double num) +void SundialsMatrixDataSparseColumn::assign(index_t row, index_t col, double num) { int sti = SM_INDEXPTRS_S(J)[col]; int stp = SM_INDEXPTRS_S(J)[col + 1]; @@ -35,22 +35,22 @@ void sundialsMatrixDataSparseColumn::assign(index_t row, index_t col, double num } } -void sundialsMatrixDataSparseColumn::setMatrix(SUNMatrix mat) +void SundialsMatrixDataSparseColumn::setMatrix(SUNMatrix mat) { J = mat; setRowLimit(static_cast(SM_ROWS_S(J))); setColLimit(static_cast(SM_COLUMNS_S(J))); } -count_t sundialsMatrixDataSparseColumn::size() const +count_t SundialsMatrixDataSparseColumn::size() const { return static_cast(SM_INDEXPTRS_S(J)[colLimit()]); } -count_t sundialsMatrixDataSparseColumn::capacity() const +count_t SundialsMatrixDataSparseColumn::capacity() const { return static_cast(SM_NNZ_S(J)); } -matrixElement sundialsMatrixDataSparseColumn::element(index_t N) const +matrixElement SundialsMatrixDataSparseColumn::element(index_t N) const { matrixElement ret; ret.row = static_cast(SM_INDEXVALS_S(J)[N]); @@ -61,13 +61,13 @@ matrixElement sundialsMatrixDataSparseColumn::element(index_t N) const return ret; } -void sundialsMatrixDataSparseColumn::start() +void SundialsMatrixDataSparseColumn::start() { cur = 0; ccol = 0; } -matrixElement sundialsMatrixDataSparseColumn::next() +matrixElement SundialsMatrixDataSparseColumn::next() { matrixElement ret{static_cast(SM_INDEXVALS_S(J)[cur]), ccol, @@ -83,7 +83,7 @@ matrixElement sundialsMatrixDataSparseColumn::next() return ret; } -double sundialsMatrixDataSparseColumn::at(index_t rowN, index_t colN) const +double SundialsMatrixDataSparseColumn::at(index_t rowN, index_t colN) const { if (static_cast(colN) > SM_COLUMNS_S(J)) { return 0.0; diff --git a/src/griddyn/solvers/sundialsMatrixDataSparseRow.cpp b/src/griddyn/solvers/sundialsMatrixDataSparseRow.cpp index 4c118df66..07149cfce 100644 --- a/src/griddyn/solvers/sundialsMatrixDataSparseRow.cpp +++ b/src/griddyn/solvers/sundialsMatrixDataSparseRow.cpp @@ -9,18 +9,18 @@ #include namespace griddyn::solvers { -sundialsMatrixDataSparseRow::sundialsMatrixDataSparseRow(SUNMatrix mat): +SundialsMatrixDataSparseRow::SundialsMatrixDataSparseRow(SUNMatrix mat): matrixData(static_cast(SM_ROWS_S(mat)), static_cast(SM_COLUMNS_S(mat))), J(mat) { } -void sundialsMatrixDataSparseRow::clear() +void SundialsMatrixDataSparseRow::clear() { SUNMatZero(J); } -void sundialsMatrixDataSparseRow::assign(index_t row, index_t col, double num) +void SundialsMatrixDataSparseRow::assign(index_t row, index_t col, double num) { int sti = SM_INDEXPTRS_S(J)[row]; int stp = SM_INDEXPTRS_S(J)[row + 1]; @@ -35,22 +35,22 @@ void sundialsMatrixDataSparseRow::assign(index_t row, index_t col, double num) } } -void sundialsMatrixDataSparseRow::setMatrix(SUNMatrix mat) +void SundialsMatrixDataSparseRow::setMatrix(SUNMatrix mat) { J = mat; setRowLimit(static_cast(SM_ROWS_S(J))); setColLimit(static_cast(SM_COLUMNS_S(J))); } -count_t sundialsMatrixDataSparseRow::size() const +count_t SundialsMatrixDataSparseRow::size() const { return static_cast(SM_INDEXPTRS_S(J)[rowLimit()]); } -count_t sundialsMatrixDataSparseRow::capacity() const +count_t SundialsMatrixDataSparseRow::capacity() const { return static_cast(SM_NNZ_S(J)); } -matrixElement sundialsMatrixDataSparseRow::element(index_t N) const +matrixElement SundialsMatrixDataSparseRow::element(index_t N) const { matrixElement ret; ret.col = static_cast(SM_INDEXVALS_S(J)[N]); @@ -61,13 +61,13 @@ matrixElement sundialsMatrixDataSparseRow::element(index_t N) const return ret; } -void sundialsMatrixDataSparseRow::start() +void SundialsMatrixDataSparseRow::start() { cur = 0; crow = 0; } -matrixElement sundialsMatrixDataSparseRow::next() +matrixElement SundialsMatrixDataSparseRow::next() { matrixElement ret{crow, static_cast(SM_INDEXVALS_S(J)[cur]), @@ -83,7 +83,7 @@ matrixElement sundialsMatrixDataSparseRow::next() return ret; } -double sundialsMatrixDataSparseRow::at(index_t rowN, index_t colN) const +double SundialsMatrixDataSparseRow::at(index_t rowN, index_t colN) const { if (static_cast(rowN) > SM_ROWS_S(J)) { return 0.0; From a1713baa048cd93a2bc6feeede3339f151a39e1a Mon Sep 17 00:00:00 2001 From: Philip Top Date: Wed, 27 May 2026 20:43:03 -0700 Subject: [PATCH 2/5] clang-tidy fixes --- src/griddyn/solvers/CvodeInterface.cpp | 32 +++---- src/griddyn/solvers/IdaInterface.cpp | 36 ++++---- src/griddyn/solvers/KinsolInterface.cpp | 18 ++-- src/griddyn/solvers/SolverInterface.cpp | 18 ++-- src/griddyn/solvers/SundialsInterface.cpp | 86 +++++++++---------- src/griddyn/solvers/SundialsMatrixData.cpp | 12 +-- .../solvers/sundialsMatrixDataDense.cpp | 12 +-- .../sundialsMatrixDataSparseColumn.cpp | 10 +-- .../solvers/sundialsMatrixDataSparseRow.cpp | 10 +-- 9 files changed, 117 insertions(+), 117 deletions(-) diff --git a/src/griddyn/solvers/CvodeInterface.cpp b/src/griddyn/solvers/CvodeInterface.cpp index 78cd2545c..e2010f62e 100644 --- a/src/griddyn/solvers/CvodeInterface.cpp +++ b/src/griddyn/solvers/CvodeInterface.cpp @@ -29,18 +29,18 @@ #include namespace griddyn::solvers { -int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_data); +int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, void* userData); int cvodeJac(sunrealtype time, N_Vector state, - N_Vector dstate_dt, - SUNMatrix J, - void* user_data, + N_Vector dstateDt, + SUNMatrix j, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3); -int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data); +int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* userData); CvodeInterface::CvodeInterface(const std::string& objName): SundialsInterface(objName) { @@ -423,14 +423,14 @@ void CvodeInterface::loadMaskElements() } // CVode C Functions -int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_data) +int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, void* userData) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(userData); sd->funcCallCount++; if (sd->mode.pairedOffsetIndex != kNullLocation) { int ret = sd->m_gds->dynAlgebraicSolve(time, NVECTOR_DATA(sd->use_omp, state), - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), sd->mode); if (ret < FUNCTION_EXECUTION_SUCCESS) { return ret; @@ -438,7 +438,7 @@ int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_d } int ret = sd->m_gds->derivativeFunction(time, NVECTOR_DATA(sd->use_omp, state), - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), sd->mode); if (sd->flags[fileCapture_flag]) { @@ -456,7 +456,7 @@ int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_d sd->funcCallCount, sd->mode.offsetIndex, sd->svsize, - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), sd->stateFile); } } @@ -464,9 +464,9 @@ int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_d return ret; } -int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data) +int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* userData) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(userData); sd->m_gds->rootFindingFunction( time, NVECTOR_DATA(sd->use_omp, state), sd->derivData(), gout, sd->mode); @@ -475,14 +475,14 @@ int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* use int cvodeJac(sunrealtype time, N_Vector state, - N_Vector dstate_dt, - SUNMatrix J, - void* user_data, + N_Vector dstateDt, + SUNMatrix j, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector /*tmp3*/) { - return sundialsJac(time, 0.0, state, dstate_dt, J, user_data, tmp1, tmp2); + return sundialsJac(time, 0.0, state, dstateDt, j, userData, tmp1, tmp2); } } // namespace griddyn::solvers diff --git a/src/griddyn/solvers/IdaInterface.cpp b/src/griddyn/solvers/IdaInterface.cpp index 3bc8255c2..88ace223b 100644 --- a/src/griddyn/solvers/IdaInterface.cpp +++ b/src/griddyn/solvers/IdaInterface.cpp @@ -33,24 +33,24 @@ #include namespace griddyn::solvers { -int idaFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, N_Vector resid, void* user_data); +int idaFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, N_Vector resid, void* userData); int idaJac(sunrealtype time, sunrealtype cj, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, N_Vector resid, - SUNMatrix J, - void* user_data, + SUNMatrix j, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3); int idaRootFunc(sunrealtype time, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, sunrealtype* gout, - void* user_data); + void* userData); IdaInterface::IdaInterface(const std::string& objName): SundialsInterface(objName) { @@ -507,13 +507,13 @@ void IdaInterface::loadMaskElements() } // IDA C Functions -int idaFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, N_Vector resid, void* user_data) +int idaFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, N_Vector resid, void* userData) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(userData); // printf("time=%f\n", time); int ret = sd->m_gds->residualFunction(time, NVECTOR_DATA(sd->use_omp, state), - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), NVECTOR_DATA(sd->use_omp, resid), sd->mode); if (sd->flags[useMask_flag]) { @@ -538,7 +538,7 @@ int idaFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, N_Vector resid sd->funcCallCount, sd->mode.offsetIndex, sd->svsize, - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), sd->stateFile); writeVector(sd->solveTime, RESIDUAL_INFORMATION, @@ -555,14 +555,14 @@ int idaFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, N_Vector resid int idaRootFunc(sunrealtype time, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, sunrealtype* gout, - void* user_data) + void* userData) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(userData); sd->m_gds->rootFindingFunction(time, NVECTOR_DATA(sd->use_omp, state), - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), gout, sd->mode); @@ -572,15 +572,15 @@ int idaRootFunc(sunrealtype time, int idaJac(sunrealtype time, sunrealtype cj, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, N_Vector /*resid*/, - SUNMatrix J, - void* user_data, + SUNMatrix j, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector /*tmp3*/) { - return sundialsJac(time, cj, state, dstate_dt, J, user_data, tmp1, tmp2); + return sundialsJac(time, cj, state, dstateDt, j, userData, tmp1, tmp2); } } // namespace griddyn::solvers diff --git a/src/griddyn/solvers/KinsolInterface.cpp b/src/griddyn/solvers/KinsolInterface.cpp index 8ee331767..2029ba0d9 100644 --- a/src/griddyn/solvers/KinsolInterface.cpp +++ b/src/griddyn/solvers/KinsolInterface.cpp @@ -33,11 +33,11 @@ #include namespace griddyn::solvers { -int kinsolFunc(N_Vector state, N_Vector resid, void* user_data); +int kinsolFunc(N_Vector state, N_Vector resid, void* userData); int kinsolJac(N_Vector state, N_Vector resid, - SUNMatrix J, - void* user_data, + SUNMatrix j, + void* userData, N_Vector tmp1, N_Vector tmp2); @@ -338,9 +338,9 @@ void KinsolInterface::setConstraints() // function not in the class // KINSOL C functions -int kinsolFunc(N_Vector state, N_Vector resid, void* user_data) +int kinsolFunc(N_Vector state, N_Vector resid, void* userData) { - auto* sd = static_cast(user_data); + auto* sd = static_cast(userData); sd->funcCallCount++; #if MEASURE_TIMINGS > 0 auto start_t = std::chrono::high_resolution_clock::now(); @@ -399,13 +399,13 @@ int kinsolFunc(N_Vector state, N_Vector resid, void* user_data) int kinsolJac(N_Vector state, N_Vector /*f*/, - SUNMatrix J, - void* user_data, + SUNMatrix j, + void* userData, N_Vector tmp1, N_Vector tmp2) { - auto* sd = static_cast(user_data); - return sundialsJac(sd->solveTime, 0, state, nullptr, J, user_data, tmp1, tmp2); + auto* sd = static_cast(userData); + return sundialsJac(sd->solveTime, 0, state, nullptr, j, userData, tmp1, tmp2); } } // namespace griddyn::solvers diff --git a/src/griddyn/solvers/SolverInterface.cpp b/src/griddyn/solvers/SolverInterface.cpp index 2b0501976..14ade4bc3 100644 --- a/src/griddyn/solvers/SolverInterface.cpp +++ b/src/griddyn/solvers/SolverInterface.cpp @@ -61,16 +61,16 @@ namespace { } // namespace static ChildClassFactoryArg - basicFactoryG(stringVec{"basic", "gauss"}, solvers::BasicSolver::Mode::gauss); + gBasicFactoryG(stringVec{"basic", "gauss"}, solvers::BasicSolver::Mode::gauss); static ChildClassFactoryArg - basicFactoryGS(stringVec{"gs", "gauss-seidel"}, solvers::BasicSolver::Mode::gauss_seidel); + gBasicFactoryGs(stringVec{"gs", "gauss-seidel"}, solvers::BasicSolver::Mode::gauss_seidel); #ifdef GRIDYN_ENABLE_CVODE static ChildClassFactory - basicOdeFactory(stringVec{"basicode", "euler"}); + gBasicOdeFactory(stringVec{"basicode", "euler"}); #else // if cvode is not available this becomes the default differential solver static ChildClassFactory - basicOdeFactory(stringVec{"basicode", "dyndiff", "differential"}); + gBasicOdeFactory(stringVec{"basicode", "dyndiff", "differential"}); #endif @@ -309,7 +309,7 @@ void SolverInterface::set(std::string_view param, double val) } } -static const std::map> solverFlagMap{ +static const std::map> SOLVER_FLAG_MAP{ {"filecapture", fileCapture_flag}, {"directlogging", directLogging_flag}, {"solver_log", directLogging_flag}, @@ -331,8 +331,8 @@ static const std::map> solver void SolverInterface::setFlag(std::string_view flag, bool val) { - const auto foundFlag = solverFlagMap.find(flag); - const int flgInd = (foundFlag != solverFlagMap.end()) ? foundFlag->second : -60; + const auto foundFlag = SOLVER_FLAG_MAP.find(flag); + const int flgInd = (foundFlag != SOLVER_FLAG_MAP.end()) ? foundFlag->second : -60; if (flgInd > -32) { if (flgInd > 0) { flags.set(flgInd, val); @@ -427,8 +427,8 @@ void SolverInterface::setApproximation(std::string_view approx) bool SolverInterface::getFlag(std::string_view flag) const { - const auto foundFlag = solverFlagMap.find(flag); - const int flgInd = (foundFlag != solverFlagMap.end()) ? foundFlag->second : -60; + const auto foundFlag = SOLVER_FLAG_MAP.find(flag); + const int flgInd = (foundFlag != SOLVER_FLAG_MAP.end()) ? foundFlag->second : -60; if (flgInd > -32) { if (flgInd > 0) { return flags[flgInd]; diff --git a/src/griddyn/solvers/SundialsInterface.cpp b/src/griddyn/solvers/SundialsInterface.cpp index 1be3350c9..a73b7c81e 100644 --- a/src/griddyn/solvers/SundialsInterface.cpp +++ b/src/griddyn/solvers/SundialsInterface.cpp @@ -140,18 +140,18 @@ void SundialsInterface::allocate(count_t stateCount, count_t /*numRoots*/) return; } - [[maybe_unused]] bool prev_omp = use_omp; // looks unused if OPENMP is not available + [[maybe_unused]] bool prevOmp = use_omp; // looks unused if OPENMP is not available use_omp = flags[use_omp_flag]; flags.reset(initialized_flag); if (state != nullptr) { - NVECTOR_DESTROY(prev_omp, state); + NVECTOR_DESTROY(prevOmp, state); } state = NVECTOR_NEW(use_omp, stateCount); checkFlag(state, "NVECTOR_NEW", 0); if (hasDifferential(mode)) { if (dstate_dt != nullptr) { - NVECTOR_DESTROY(prev_omp, dstate_dt); + NVECTOR_DESTROY(prevOmp, dstate_dt); } dstate_dt = NVECTOR_NEW(use_omp, stateCount); checkFlag(dstate_dt, "NVECTOR_NEW", 0); @@ -159,19 +159,19 @@ void SundialsInterface::allocate(count_t stateCount, count_t /*numRoots*/) N_VConst(ZERO, dstate_dt); } if (abstols != nullptr) { - NVECTOR_DESTROY(prev_omp, abstols); + NVECTOR_DESTROY(prevOmp, abstols); } abstols = NVECTOR_NEW(use_omp, stateCount); checkFlag(abstols, "NVECTOR_NEW", 0); if (consData != nullptr) { - NVECTOR_DESTROY(prev_omp, consData); + NVECTOR_DESTROY(prevOmp, consData); } consData = NVECTOR_NEW(use_omp, stateCount); checkFlag(consData, "NVECTOR_NEW", 0); if (scale != nullptr) { - NVECTOR_DESTROY(prev_omp, scale); + NVECTOR_DESTROY(prevOmp, scale); } scale = NVECTOR_NEW(use_omp, stateCount); checkFlag(scale, "NVECTOR_NEW", 0); @@ -180,7 +180,7 @@ void SundialsInterface::allocate(count_t stateCount, count_t /*numRoots*/) if (isDAE(mode)) { if (types != nullptr) { - NVECTOR_DESTROY(prev_omp, types); + NVECTOR_DESTROY(prevOmp, types); } types = NVECTOR_NEW(use_omp, stateCount); checkFlag(types, "NVECTOR_NEW", 0); @@ -275,31 +275,31 @@ void SundialsInterface::kluReInit(SparseReinitMode sparseReInitModes) #endif } -bool isSUNMatrixSetup(SUNMatrix J) +bool isSUNMatrixSetup(SUNMatrix j) { - int id = SUNMatGetID(J); + int id = SUNMatGetID(j); if (id == SUNMATRIX_SPARSE) { - auto M = SM_CONTENT_S(J); - if ((M->indexptrs[0] != 0) || (M->indexptrs[0] > M->NNZ)) { + auto m = SM_CONTENT_S(j); + if ((m->indexptrs[0] != 0) || (m->indexptrs[0] > m->NNZ)) { return false; } - if ((M->indexptrs[M->N] <= 0) || (M->indexptrs[M->N] >= M->NNZ)) { + if ((m->indexptrs[m->N] <= 0) || (m->indexptrs[m->N] >= m->NNZ)) { return false; } } return true; } -void matrixDataToSUNMatrix(matrixData& md, SUNMatrix J, count_t svsize) +void matrixDataToSUNMatrix(matrixData& md, SUNMatrix j, count_t svsize) { - int id = SUNMatGetID(J); + int id = SUNMatGetID(j); if (id == SUNMATRIX_SPARSE) { - auto M = SM_CONTENT_S(J); + auto m = SM_CONTENT_S(j); count_t indval = 0; - M->indexptrs[0] = indval; + m->indexptrs[0] = indval; md.compact(); - assert(M->NNZ >= static_cast(md.size())); + assert(m->NNZ >= static_cast(md.size())); auto sz = static_cast(md.size()); /* auto itel = md.begin(); @@ -328,19 +328,19 @@ void matrixDataToSUNMatrix(matrixData& md, SUNMatrix J, count_t svsize) // a1->colIndex(kk)); if (tp.row > indval) { indval++; - M->indexptrs[indval] = kk; + m->indexptrs[indval] = kk; assert(tp.row == indval); } - M->data[kk] = tp.data; - M->indexvals[kk] = tp.col; + m->data[kk] = tp.data; + m->indexvals[kk] = tp.col; } if (indval + 1 != svsize) { std::println("sz={}, svsize={}, colval+1={}", sz, svsize, indval + 1); } assert(indval + 1 == svsize); - M->indexptrs[indval + 1] = sz; + m->indexptrs[indval + 1] = sz; } else if (id == SUNMATRIX_DENSE) { } } @@ -350,26 +350,26 @@ void sundialsErrorHandlerFunc(int line, const char* function, const char* file, const char* msg, - SUNErrCode error_code, - void* user_data, + SUNErrCode errorCode, + void* userData, SUNContext /*sunctx*/) { - if (error_code == 0) { + if (errorCode == 0) { return; } - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(userData); auto message = - std::format("SUNDIALS ERROR({}) in {} [{}:{}]::{}", error_code, function, file, line, msg); - sd->logMessage(error_code, message); + std::format("SUNDIALS ERROR({}) in {} [{}:{}]::{}", errorCode, function, file, line, msg); + sd->logMessage(errorCode, message); } -bool matrixNeedsSetup(count_t callCount, SUNMatrix J) +bool matrixNeedsSetup(count_t callCount, SUNMatrix j) { - switch (SUNMatGetID(J)) { + switch (SUNMatGetID(j)) { case SUNMATRIX_DENSE: return false; case SUNMATRIX_SPARSE: - return ((callCount == 0) || (!isSUNMatrixSetup(J))); + return ((callCount == 0) || (!isSUNMatrixSetup(j))); default: return false; } @@ -379,15 +379,15 @@ bool matrixNeedsSetup(count_t callCount, SUNMatrix J) int sundialsJac(sunrealtype time, sunrealtype cj, N_Vector state, - N_Vector dstate_dt, - SUNMatrix J, - void* user_data, + N_Vector dstateDt, + SUNMatrix j, + void* userData, N_Vector /*tmp1*/, N_Vector /*tmp2*/) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(userData); - if (matrixNeedsSetup(sd->jacCallCount, J)) { + if (matrixNeedsSetup(sd->jacCallCount, j)) { auto a1 = makeSparseMatrix(sd->svsize, sd->maxNNZ); a1->setRowLimit(sd->svsize); @@ -398,7 +398,7 @@ int sundialsJac(sunrealtype time, filterAd.addFilter(sd->maskElements); sd->m_gds->jacobianFunction(time, nvecdata(sd->use_omp, state), - nvecdata(sd->use_omp, dstate_dt), + nvecdata(sd->use_omp, dstateDt), filterAd, cj, sd->mode); @@ -408,7 +408,7 @@ int sundialsJac(sunrealtype time, } else { sd->m_gds->jacobianFunction(time, nvecdata(sd->use_omp, state), - nvecdata(sd->use_omp, dstate_dt), + nvecdata(sd->use_omp, dstateDt), *a1, cj, sd->mode); @@ -416,14 +416,14 @@ int sundialsJac(sunrealtype time, ++sd->jacCallCount; #ifdef _DEBUG - if (SM_CONTENT_S(J)->NNZ < static_cast(a1->size())) { + if (SM_CONTENT_S(j)->NNZ < static_cast(a1->size())) { a1->compact(); - if (SM_CONTENT_S(J)->NNZ < static_cast(a1->size())) { + if (SM_CONTENT_S(j)->NNZ < static_cast(a1->size())) { jacobianAnalysis(*a1, sd->m_gds, sd->mode, 5); } } #endif - matrixDataToSUNMatrix(*a1, J, sd->svsize); + matrixDataToSUNMatrix(*a1, j, sd->svsize); sd->nnz = a1->size(); if (sd->flags[fileCapture_flag]) { if (!sd->jacFile.empty()) { @@ -433,13 +433,13 @@ int sundialsJac(sunrealtype time, } } else { // if it isn't the first we can use the SUNDIALS arraySparse object - auto a1 = makeSundialsMatrixData(J); + auto a1 = makeSundialsMatrixData(j); if (sd->flags[useMask_flag]) { matrixDataFilter filterAd(*a1); filterAd.addFilter(sd->maskElements); sd->m_gds->jacobianFunction(time, nvecdata(sd->use_omp, state), - nvecdata(sd->use_omp, dstate_dt), + nvecdata(sd->use_omp, dstateDt), filterAd, cj, sd->mode); @@ -449,7 +449,7 @@ int sundialsJac(sunrealtype time, } else { sd->m_gds->jacobianFunction(time, nvecdata(sd->use_omp, state), - nvecdata(sd->use_omp, dstate_dt), + nvecdata(sd->use_omp, dstateDt), *a1, cj, sd->mode); diff --git a/src/griddyn/solvers/SundialsMatrixData.cpp b/src/griddyn/solvers/SundialsMatrixData.cpp index f801d669c..d55721437 100644 --- a/src/griddyn/solvers/SundialsMatrixData.cpp +++ b/src/griddyn/solvers/SundialsMatrixData.cpp @@ -11,16 +11,16 @@ #include namespace griddyn::solvers { -std::unique_ptr> makeSundialsMatrixData(SUNMatrix J) +std::unique_ptr> makeSundialsMatrixData(SUNMatrix j) { - switch (SUNMatGetID(J)) { + switch (SUNMatGetID(j)) { case SUNMATRIX_DENSE: - return std::make_unique(J); + return std::make_unique(j); case SUNMATRIX_SPARSE: - if (SM_SPARSETYPE_S(J) == CSR_MAT) { - return std::make_unique(J); + if (SM_SPARSETYPE_S(j) == CSR_MAT) { + return std::make_unique(j); } else { - return std::make_unique(J); + return std::make_unique(j); } case SUNMATRIX_CUSTOM: default: diff --git a/src/griddyn/solvers/sundialsMatrixDataDense.cpp b/src/griddyn/solvers/sundialsMatrixDataDense.cpp index 5ad8f5e8e..0c280c1f5 100644 --- a/src/griddyn/solvers/sundialsMatrixDataDense.cpp +++ b/src/griddyn/solvers/sundialsMatrixDataDense.cpp @@ -19,9 +19,9 @@ void SundialsMatrixDataDense::clear() { SUNMatZero(J); } -void SundialsMatrixDataDense::assign(index_t X, index_t Y, double num) +void SundialsMatrixDataDense::assign(index_t x, index_t y, double num) { - SM_ELEMENT_D(J, X, Y) += num; + SM_ELEMENT_D(J, x, y) += num; } void SundialsMatrixDataDense::setMatrix(SUNMatrix mat) { @@ -38,11 +38,11 @@ count_t SundialsMatrixDataDense::capacity() const { return static_cast(SM_ROWS_D(J) * SM_COLUMNS_D(J)); } -matrixElement SundialsMatrixDataDense::element(index_t N) const +matrixElement SundialsMatrixDataDense::element(index_t n) const { - return {N % static_cast(SM_COLUMNS_D(J)), - N / static_cast(SM_COLUMNS_D(J)), - SM_DATA_D(J)[N]}; + return {n % static_cast(SM_COLUMNS_D(J)), + n / static_cast(SM_COLUMNS_D(J)), + SM_DATA_D(J)[n]}; } double SundialsMatrixDataDense::at(index_t rowN, index_t colN) const diff --git a/src/griddyn/solvers/sundialsMatrixDataSparseColumn.cpp b/src/griddyn/solvers/sundialsMatrixDataSparseColumn.cpp index fc7f730b5..6b0cd2ff7 100644 --- a/src/griddyn/solvers/sundialsMatrixDataSparseColumn.cpp +++ b/src/griddyn/solvers/sundialsMatrixDataSparseColumn.cpp @@ -50,14 +50,14 @@ count_t SundialsMatrixDataSparseColumn::capacity() const { return static_cast(SM_NNZ_S(J)); } -matrixElement SundialsMatrixDataSparseColumn::element(index_t N) const +matrixElement SundialsMatrixDataSparseColumn::element(index_t n) const { - matrixElement ret; - ret.row = static_cast(SM_INDEXVALS_S(J)[N]); + matrixElement ret{}; + ret.row = static_cast(SM_INDEXVALS_S(J)[n]); auto res = - std::lower_bound(SM_INDEXPTRS_S(J), &(SM_INDEXPTRS_S(J)[colLimit()]), static_cast(N)); + std::lower_bound(SM_INDEXPTRS_S(J), &(SM_INDEXPTRS_S(J)[colLimit()]), static_cast(n)); ret.col = static_cast(*res - 1); - ret.data = SM_DATA_S(J)[N]; + ret.data = SM_DATA_S(J)[n]; return ret; } diff --git a/src/griddyn/solvers/sundialsMatrixDataSparseRow.cpp b/src/griddyn/solvers/sundialsMatrixDataSparseRow.cpp index 07149cfce..b3c833a37 100644 --- a/src/griddyn/solvers/sundialsMatrixDataSparseRow.cpp +++ b/src/griddyn/solvers/sundialsMatrixDataSparseRow.cpp @@ -50,14 +50,14 @@ count_t SundialsMatrixDataSparseRow::capacity() const { return static_cast(SM_NNZ_S(J)); } -matrixElement SundialsMatrixDataSparseRow::element(index_t N) const +matrixElement SundialsMatrixDataSparseRow::element(index_t n) const { - matrixElement ret; - ret.col = static_cast(SM_INDEXVALS_S(J)[N]); + matrixElement ret{}; + ret.col = static_cast(SM_INDEXVALS_S(J)[n]); auto res = - std::lower_bound(SM_INDEXPTRS_S(J), &(SM_INDEXPTRS_S(J)[rowLimit()]), static_cast(N)); + std::lower_bound(SM_INDEXPTRS_S(J), &(SM_INDEXPTRS_S(J)[rowLimit()]), static_cast(n)); ret.row = static_cast(*res - 1); - ret.data = SM_DATA_S(J)[N]; + ret.data = SM_DATA_S(J)[n]; return ret; } From 6ce334c4ff4a0f07876de88280e4e52573f8aa7f Mon Sep 17 00:00:00 2001 From: Philip Top Date: Thu, 28 May 2026 04:45:35 -0700 Subject: [PATCH 3/5] more clang-tidy fixes --- src/griddyn/solvers/CvodeInterface.h | 8 ++++---- src/griddyn/solvers/IdaInterface.h | 12 ++++++------ src/griddyn/solvers/KinsolInterface.h | 4 ++-- src/griddyn/solvers/SundialsInterface.h | 12 ++++++------ 4 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/griddyn/solvers/CvodeInterface.h b/src/griddyn/solvers/CvodeInterface.h index e611466af..7f6818d32 100644 --- a/src/griddyn/solvers/CvodeInterface.h +++ b/src/griddyn/solvers/CvodeInterface.h @@ -57,18 +57,18 @@ class CvodeInterface: public SundialsInterface { virtual double get(std::string_view param) const override; // declare friend some helper functions - friend int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_data); + friend int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, void* userData); friend int cvodeJac(sunrealtype time, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, SUNMatrix J, - void* user_data, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3); - friend int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data); + friend int cvodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* userData); protected: void loadMaskElements(); diff --git a/src/griddyn/solvers/IdaInterface.h b/src/griddyn/solvers/IdaInterface.h index 7c33ef6ea..cab07f6b6 100644 --- a/src/griddyn/solvers/IdaInterface.h +++ b/src/griddyn/solvers/IdaInterface.h @@ -58,26 +58,26 @@ class IdaInterface: public SundialsInterface { // declare friend some helper functions friend int idaFunc(sunrealtype time, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, N_Vector resid, - void* user_data); + void* userData); friend int idaJac(sunrealtype time, sunrealtype cj, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, N_Vector resid, SUNMatrix J, - void* user_data, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3); friend int idaRootFunc(sunrealtype time, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, sunrealtype* gout, - void* user_data); + void* userData); protected: void loadMaskElements(); diff --git a/src/griddyn/solvers/KinsolInterface.h b/src/griddyn/solvers/KinsolInterface.h index d43f50399..dc263485e 100644 --- a/src/griddyn/solvers/KinsolInterface.h +++ b/src/griddyn/solvers/KinsolInterface.h @@ -42,11 +42,11 @@ class KinsolInterface: public SundialsInterface { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val) override; // wrapper functions used by kinsol and ida to call the internal functions - friend int kinsolFunc(N_Vector state, N_Vector resid, void* user_data); + friend int kinsolFunc(N_Vector state, N_Vector resid, void* userData); friend int kinsolJac(N_Vector state, N_Vector resid, SUNMatrix J, - void* user_data, + void* userData, N_Vector tmp1, N_Vector tmp2); diff --git a/src/griddyn/solvers/SundialsInterface.h b/src/griddyn/solvers/SundialsInterface.h index 40a8573dd..b71144029 100644 --- a/src/griddyn/solvers/SundialsInterface.h +++ b/src/griddyn/solvers/SundialsInterface.h @@ -50,8 +50,8 @@ void sundialsErrorHandlerFunc(int line, const char* function, const char* file, const char* msg, - SUNErrCode error_code, - void* user_data, + SUNErrCode errorCode, + void* userData, SUNContext sunctx); #ifdef GRIDDYN_ENABLE_KLU @@ -119,9 +119,9 @@ class SundialsInterface: public SolverInterface { friend int sundialsJac(sunrealtype time, sunrealtype cj, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, SUNMatrix J, - void* user_data, + void* userData, N_Vector tmp1, N_Vector tmp2); @@ -133,9 +133,9 @@ class SundialsInterface: public SolverInterface { int sundialsJac(sunrealtype time, sunrealtype cj, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, SUNMatrix J, - void* user_data, + void* userData, N_Vector tmp1, N_Vector tmp2); From 6f63434b9355b69bc0733940a4bf8a2fba20ae7c Mon Sep 17 00:00:00 2001 From: Philip Top Date: Thu, 28 May 2026 05:34:48 -0700 Subject: [PATCH 4/5] more renaming --- src/extraModels/txLifeSpan.cpp | 2 +- src/extraModels/txLifeSpan.h | 2 +- src/extraModels/txThermalModel.cpp | 2 +- src/extraModels/txThermalModel.h | 2 +- src/extraSolvers/braid/braidInterface.h | 4 +- src/extraSolvers/braid/braidSolver.cpp | 12 +- .../paradae/equations/EqGridDyn.cxx | 2 +- .../paradae/equations/EqGridDyn.h | 6 +- src/fileInput/readSolverElement.cpp | 2 +- src/fmi/fmi_models/fmiCoSimLoad.cpp | 2 +- src/fmi/fmi_models/fmiCoSimLoad.h | 2 +- src/fmi/fmi_models/fmiCoSimLoad3phase.cpp | 2 +- src/fmi/fmi_models/fmiCoSimLoad3phase.h | 2 +- src/fmi/fmi_models/fmiCoSimSubModel.cpp | 12 +- src/fmi/fmi_models/fmiCoSimSubModel.h | 12 +- src/fmi/fmi_models/fmiCoSimWrapper.hpp | 20 +- src/fmi/fmi_models/fmiMELoad.cpp | 4 +- src/fmi/fmi_models/fmiMELoad.h | 4 +- src/fmi/fmi_models/fmiMELoad3phase.cpp | 4 +- src/fmi/fmi_models/fmiMELoad3phase.h | 4 +- src/fmi/fmi_models/fmiMESubModel.cpp | 42 +- src/fmi/fmi_models/fmiMESubModel.h | 42 +- src/fmi/fmi_models/fmiMEWrapper.hpp | 20 +- src/fmi/fmi_models/fmiWrapper.hpp | 2 +- src/griddyn/Block.h | 48 +- src/griddyn/Exciter.h | 12 +- src/griddyn/GenModel.h | 12 +- src/griddyn/Generator.h | 40 +- src/griddyn/Governor.h | 12 +- src/griddyn/GridArea.h | 78 ++-- src/griddyn/GridBus.h | 56 +-- src/griddyn/GridComponent.cpp | 118 ++--- src/griddyn/GridComponent.h | 184 ++++---- src/griddyn/GridComponentHelperClasses.h | 2 +- src/griddyn/GridDynGovernor.h | 12 +- src/griddyn/GridDynSimulation.h | 150 +++---- src/griddyn/GridPrimary.cpp | 12 +- src/griddyn/GridPrimary.h | 22 +- src/griddyn/GridSecondary.cpp | 12 +- src/griddyn/GridSecondary.h | 12 +- src/griddyn/Link.h | 22 +- src/griddyn/Load.h | 6 +- src/griddyn/NumericEstimationFunctions.cpp | 6 +- src/griddyn/NumericEstimationFunctions.h | 8 +- src/griddyn/OffsetTable.cpp | 38 +- src/griddyn/OffsetTable.h | 108 ++--- src/griddyn/Relay.h | 8 +- src/griddyn/Source.h | 14 +- src/griddyn/Stabilizer.h | 8 +- src/griddyn/blocks/Block.cpp | 32 +- src/griddyn/blocks/BlockSequence.cpp | 16 +- src/griddyn/blocks/BlockSequence.h | 16 +- src/griddyn/blocks/ControlBlock.cpp | 8 +- src/griddyn/blocks/ControlBlock.h | 8 +- src/griddyn/blocks/DeadbandBlock.cpp | 12 +- src/griddyn/blocks/DeadbandBlock.h | 16 +- src/griddyn/blocks/DelayBlock.cpp | 4 +- src/griddyn/blocks/DelayBlock.h | 6 +- src/griddyn/blocks/DerivativeBlock.cpp | 6 +- src/griddyn/blocks/DerivativeBlock.h | 8 +- .../blocks/FilteredDerivativeBlock.cpp | 4 +- src/griddyn/blocks/FilteredDerivativeBlock.h | 6 +- src/griddyn/blocks/FunctionBlock.cpp | 6 +- src/griddyn/blocks/FunctionBlock.h | 8 +- src/griddyn/blocks/IntegralBlock.cpp | 6 +- src/griddyn/blocks/IntegralBlock.h | 10 +- src/griddyn/blocks/LutBlock.cpp | 4 +- src/griddyn/blocks/LutBlock.h | 6 +- src/griddyn/blocks/NullBlock.cpp | 20 +- src/griddyn/blocks/NullBlock.h | 20 +- src/griddyn/blocks/PidBlock.cpp | 6 +- src/griddyn/blocks/PidBlock.h | 6 +- src/griddyn/blocks/TransferFunctionBlock.cpp | 8 +- src/griddyn/blocks/TransferFunctionBlock.h | 8 +- src/griddyn/controllers/AGControl.cpp | 4 +- src/griddyn/controllers/AGControl.h | 4 +- src/griddyn/controllers/ControlSystem.cpp | 14 +- src/griddyn/controllers/ControlSystem.h | 14 +- src/griddyn/exciters/Exciter.cpp | 28 +- src/griddyn/exciters/ExciterDC1A.cpp | 10 +- src/griddyn/exciters/ExciterDC1A.h | 10 +- src/griddyn/exciters/ExciterDC2A.cpp | 8 +- src/griddyn/exciters/ExciterDC2A.h | 8 +- src/griddyn/exciters/ExciterIEEEtype1.cpp | 12 +- src/griddyn/exciters/ExciterIEEEtype1.h | 12 +- src/griddyn/exciters/ExciterIEEEtype2.cpp | 10 +- src/griddyn/exciters/ExciterIEEEtype2.h | 10 +- src/griddyn/exciters/ExciterSEXS.cpp | 32 +- src/griddyn/exciters/ExciterSEXS.h | 12 +- src/griddyn/generators/DynamicGenerator.cpp | 54 +-- src/griddyn/generators/DynamicGenerator.h | 54 +-- src/griddyn/generators/Generator.cpp | 36 +- src/griddyn/generators/IsocController.cpp | 2 +- src/griddyn/generators/IsocController.h | 2 +- src/griddyn/generators/VariableGenerator.cpp | 8 +- src/griddyn/generators/VariableGenerator.h | 8 +- src/griddyn/genmodels/GenModel.cpp | 12 +- src/griddyn/genmodels/GenModel3.cpp | 8 +- src/griddyn/genmodels/GenModel3.h | 8 +- src/griddyn/genmodels/GenModel4.cpp | 10 +- src/griddyn/genmodels/GenModel4.h | 10 +- src/griddyn/genmodels/GenModel5.cpp | 8 +- src/griddyn/genmodels/GenModel5.h | 8 +- src/griddyn/genmodels/GenModel5type2.cpp | 8 +- src/griddyn/genmodels/GenModel5type2.h | 8 +- src/griddyn/genmodels/GenModel5type3.cpp | 6 +- src/griddyn/genmodels/GenModel5type3.h | 6 +- src/griddyn/genmodels/GenModel6.cpp | 8 +- src/griddyn/genmodels/GenModel6.h | 8 +- src/griddyn/genmodels/GenModel6type2.cpp | 8 +- src/griddyn/genmodels/GenModel6type2.h | 8 +- src/griddyn/genmodels/GenModel8.cpp | 6 +- src/griddyn/genmodels/GenModel8.h | 6 +- src/griddyn/genmodels/GenModelClassical.cpp | 24 +- src/griddyn/genmodels/GenModelClassical.h | 24 +- src/griddyn/genmodels/GenModelGENROU.cpp | 8 +- src/griddyn/genmodels/GenModelGENROU.h | 8 +- src/griddyn/genmodels/GenModelInverter.cpp | 26 +- src/griddyn/genmodels/GenModelInverter.h | 26 +- src/griddyn/governors/Governor.cpp | 12 +- src/griddyn/governors/GovernorHydro.cpp | 6 +- src/griddyn/governors/GovernorHydro.h | 6 +- src/griddyn/governors/GovernorIeeeSimple.cpp | 14 +- src/griddyn/governors/GovernorIeeeSimple.h | 14 +- src/griddyn/governors/GovernorReheat.cpp | 10 +- src/griddyn/governors/GovernorReheat.h | 8 +- src/griddyn/governors/GovernorSteamNR.cpp | 6 +- src/griddyn/governors/GovernorSteamNR.h | 6 +- src/griddyn/governors/GovernorSteamTCSR.cpp | 6 +- src/griddyn/governors/GovernorSteamTCSR.h | 6 +- src/griddyn/governors/GovernorTgov1.cpp | 14 +- src/griddyn/governors/GovernorTgov1.h | 14 +- src/griddyn/links/AcLine.cpp | 62 +-- src/griddyn/links/AcLine.h | 22 +- src/griddyn/links/AcdcConverter.cpp | 22 +- src/griddyn/links/AcdcConverter.h | 24 +- src/griddyn/links/AdjustableTransformer.cpp | 36 +- src/griddyn/links/AdjustableTransformer.h | 44 +- src/griddyn/links/DcLink.cpp | 24 +- src/griddyn/links/DcLink.h | 24 +- src/griddyn/links/Link.cpp | 20 +- src/griddyn/links/Subsystem.cpp | 20 +- src/griddyn/links/Subsystem.h | 26 +- src/griddyn/links/ZBreaker.cpp | 2 +- src/griddyn/links/ZBreaker.h | 2 +- src/griddyn/loads/AggregateLoad.cpp | 16 +- src/griddyn/loads/AggregateLoad.h | 16 +- src/griddyn/loads/ApproximatingLoad.cpp | 12 +- src/griddyn/loads/ApproximatingLoad.h | 12 +- src/griddyn/loads/ExponentialLoad.cpp | 6 +- src/griddyn/loads/ExponentialLoad.h | 6 +- src/griddyn/loads/FDepLoad.cpp | 6 +- src/griddyn/loads/FDepLoad.h | 6 +- src/griddyn/loads/FileLoad.cpp | 2 +- src/griddyn/loads/FileLoad.h | 2 +- src/griddyn/loads/FrequencySensitiveLoad.cpp | 16 +- src/griddyn/loads/FrequencySensitiveLoad.h | 16 +- src/griddyn/loads/GridLabDLoad.cpp | 12 +- src/griddyn/loads/GridLabDLoad.h | 12 +- src/griddyn/loads/Load.cpp | 6 +- src/griddyn/loads/MotorLoad.cpp | 38 +- src/griddyn/loads/MotorLoad.h | 38 +- src/griddyn/loads/MotorLoad3.cpp | 38 +- src/griddyn/loads/MotorLoad3.h | 38 +- src/griddyn/loads/MotorLoad5.cpp | 24 +- src/griddyn/loads/MotorLoad5.h | 24 +- src/griddyn/loads/RampLoad.cpp | 2 +- src/griddyn/loads/RampLoad.h | 2 +- src/griddyn/loads/SourceLoad.cpp | 6 +- src/griddyn/loads/SourceLoad.h | 6 +- src/griddyn/loads/Svd.cpp | 24 +- src/griddyn/loads/Svd.h | 24 +- src/griddyn/loads/ThreePhaseLoad.cpp | 4 +- src/griddyn/loads/ThreePhaseLoad.h | 4 +- src/griddyn/loads/ZipLoad.cpp | 16 +- src/griddyn/loads/ZipLoad.h | 16 +- src/griddyn/measurement/Condition.cpp | 6 +- src/griddyn/measurement/Condition.h | 12 +- src/griddyn/measurement/GrabberSet.cpp | 4 +- src/griddyn/measurement/GrabberSet.h | 8 +- src/griddyn/measurement/StateGrabber.h | 20 +- src/griddyn/measurement/compoundCondition.cpp | 4 +- src/griddyn/measurement/stateGrabbers.cpp | 50 +-- src/griddyn/primary/AcBus.cpp | 72 +-- src/griddyn/primary/AcBus.h | 90 ++-- src/griddyn/primary/DcBus.cpp | 34 +- src/griddyn/primary/DcBus.h | 32 +- src/griddyn/primary/GridArea.cpp | 72 +-- src/griddyn/primary/GridBus.cpp | 42 +- src/griddyn/primary/InfiniteBus.cpp | 14 +- src/griddyn/primary/InfiniteBus.h | 14 +- src/griddyn/primary/ListMaintainer.cpp | 46 +- src/griddyn/primary/ListMaintainer.h | 52 +-- src/griddyn/relays/Breaker.cpp | 20 +- src/griddyn/relays/Breaker.h | 16 +- src/griddyn/relays/Fuse.cpp | 20 +- src/griddyn/relays/Fuse.h | 18 +- src/griddyn/relays/Relay.cpp | 8 +- src/griddyn/relays/Sensor.cpp | 32 +- src/griddyn/relays/Sensor.h | 38 +- src/griddyn/simulation/Diagnostics.cpp | 36 +- src/griddyn/simulation/Diagnostics.h | 26 +- .../DynamicInitialConditionRecovery.cpp | 24 +- src/griddyn/simulation/FaultResetRecovery.cpp | 10 +- src/griddyn/simulation/GridDynSimulation.cpp | 50 +-- .../simulation/GridDynSimulationFileOps.cpp | 22 +- .../simulation/GridDynSimulationFileOps.h | 24 +- src/griddyn/simulation/GridSimulation.cpp | 2 +- src/griddyn/simulation/GridSimulation.h | 2 +- src/griddyn/simulation/gridDynDynamic.cpp | 70 +-- src/griddyn/simulation/gridDynPowerFlow.cpp | 10 +- src/griddyn/solvers/ArkodeInterface.cpp | 46 +- src/griddyn/solvers/ArkodeInterface.h | 12 +- src/griddyn/solvers/BasicOdeSolver.cpp | 10 +- src/griddyn/solvers/BasicOdeSolver.h | 4 +- src/griddyn/solvers/BasicSolver.cpp | 14 +- src/griddyn/solvers/BasicSolver.h | 4 +- src/griddyn/solvers/CvodeInterface.cpp | 18 +- src/griddyn/solvers/CvodeInterface.h | 4 +- src/griddyn/solvers/IdaInterface.cpp | 32 +- src/griddyn/solvers/IdaInterface.h | 4 +- src/griddyn/solvers/KinsolInterface.cpp | 18 +- src/griddyn/solvers/KinsolInterface.h | 4 +- src/griddyn/solvers/SolverInterface.cpp | 88 ++-- src/griddyn/solvers/SolverInterface.h | 82 ++-- src/griddyn/solvers/SolverMode.hpp | 116 ++--- src/griddyn/solvers/SundialsInterface.cpp | 26 +- src/griddyn/solvers/SundialsInterface.h | 4 +- src/griddyn/solvers/SundialsMatrixData.h | 10 +- src/griddyn/sources/BlockSource.cpp | 26 +- src/griddyn/sources/BlockSource.h | 26 +- src/griddyn/sources/FileSource.cpp | 2 +- src/griddyn/sources/FileSource.h | 2 +- src/griddyn/sources/FunctionSource.cpp | 6 +- src/griddyn/sources/FunctionSource.h | 6 +- src/griddyn/sources/GrabberSource.cpp | 6 +- src/griddyn/sources/GrabberSource.h | 6 +- src/griddyn/sources/PulseSource.cpp | 2 +- src/griddyn/sources/PulseSource.h | 2 +- src/griddyn/sources/RampSource.cpp | 2 +- src/griddyn/sources/RampSource.h | 2 +- src/griddyn/sources/RandomSource.cpp | 2 +- src/griddyn/sources/RandomSource.h | 2 +- src/griddyn/sources/Source.cpp | 14 +- src/griddyn/stabilizers/Stabilizer.cpp | 8 +- src/griddyn_shared/griddyn_export.h | 2 +- .../griddyn_exportObjectMathFunctions.cpp | 6 +- .../internal/griddyn_export_internal.h | 10 +- src/helics/helicsGhostBus.cpp | 2 +- src/helics/helicsGhostBus.h | 2 +- src/helics/helicsLoad.cpp | 2 +- src/helics/helicsLoad.h | 2 +- src/helics/helicsSource.cpp | 2 +- src/helics/helicsSource.h | 2 +- test/extraTests/objectSizeReport.cpp | 2 +- test/gtestHelper.h | 12 +- test/gtestHelperFunctions.cpp | 10 +- test/test_files/IEEE_test_cases/118BUS.JPG | Bin 70514 -> 70516 bytes test/test_files/IEEE_test_cases/14bus.jpg | Bin 57868 -> 57870 bytes test/test_files/IEEE_test_cases/300BUS.JPG | Bin 70528 -> 70530 bytes test/test_files/IEEE_test_cases/30bus.jpg | Bin 67750 -> 67752 bytes test/test_files/IEEE_test_cases/57bus.jpg | Bin 39239 -> 39241 bytes test/test_files/IEEE_test_cases/IEEE 118.pdf | Bin 256906 -> 256908 bytes test/test_files/IEEE_test_cases/IEEE 57.pdf | Bin 164731 -> 164733 bytes test/test_files/IEEE_test_cases/IEEE 9.pdf | Bin 158067 -> 158069 bytes .../extraModel_tests/temperatures.bin | Bin 24241 -> 24242 bytes .../fmi_tests/test_fmus/DUMMY_0CYMDIST.fmu | Bin 896181 -> 896183 bytes .../fmi_tests/test_fmus/Rectifier.fmu | Bin 1436135 -> 1436137 bytes .../fmi_tests/test_fmus/Rectifier2.fmu | Bin 64110 -> 64112 bytes .../fmi_tests/test_fmus/vanDerPol.fmu | 412 +++++++++--------- test/test_files/load_tests/FileLoadInfo.bin | Bin 97 -> 98 bytes test/test_files/load_tests/testLoad.bin | Bin 24232 -> 24233 bytes test/test_files/zip_tests/Rectifier.fmu | Bin 1436135 -> 1436137 bytes 273 files changed, 2519 insertions(+), 2519 deletions(-) diff --git a/src/extraModels/txLifeSpan.cpp b/src/extraModels/txLifeSpan.cpp index 7cf898765..8da7ec3c6 100644 --- a/src/extraModels/txLifeSpan.cpp +++ b/src/extraModels/txLifeSpan.cpp @@ -184,7 +184,7 @@ void txLifeSpan::updateA(coreTime time) prevTime = time; } -void txLifeSpan::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void txLifeSpan::timestep(coreTime time, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { updateA(time); } diff --git a/src/extraModels/txLifeSpan.h b/src/extraModels/txLifeSpan.h index caacf432f..80f596b58 100644 --- a/src/extraModels/txLifeSpan.h +++ b/src/extraModels/txLifeSpan.h @@ -49,7 +49,7 @@ class txLifeSpan: public sensor { const IOdata& desiredOutput, IOdata& fieldSet) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void updateA(coreTime time) override; void actionTaken(index_t actionNumber, diff --git a/src/extraModels/txThermalModel.cpp b/src/extraModels/txThermalModel.cpp index e219be946..de66128db 100644 --- a/src/extraModels/txThermalModel.cpp +++ b/src/extraModels/txThermalModel.cpp @@ -386,7 +386,7 @@ void txThermalModel::updateA(coreTime time) prevTime = time; } -void txThermalModel::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void txThermalModel::timestep(coreTime time, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { updateA(time); } diff --git a/src/extraModels/txThermalModel.h b/src/extraModels/txThermalModel.h index 143c99a35..a34bb7e42 100644 --- a/src/extraModels/txThermalModel.h +++ b/src/extraModels/txThermalModel.h @@ -58,7 +58,7 @@ class txThermalModel: public sensor { const IOdata& desiredOutput, IOdata& fieldSet) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void updateA(coreTime time) override; }; diff --git a/src/extraSolvers/braid/braidInterface.h b/src/extraSolvers/braid/braidInterface.h index b9ab4b448..fa107127e 100644 --- a/src/extraSolvers/braid/braidInterface.h +++ b/src/extraSolvers/braid/braidInterface.h @@ -40,9 +40,9 @@ class braidSolver: public SolverInterface { explicit braidSolver(const std::string& objName = "braid"); /** alternate constructor to feed to solverInterface @param[in] gds the GridDynSimulation to link to -@param[in] sMode the solverMode to solve with +@param[in] sMode the SolverMode to solve with */ - braidSolver(GridDynSimulation* gds, const solverMode& sMode); + braidSolver(GridDynSimulation* gds, const SolverMode& sMode); Equation* equation = nullptr; diff --git a/src/extraSolvers/braid/braidSolver.cpp b/src/extraSolvers/braid/braidSolver.cpp index 143f888f0..70d0077d1 100644 --- a/src/extraSolvers/braid/braidSolver.cpp +++ b/src/extraSolvers/braid/braidSolver.cpp @@ -129,9 +129,9 @@ braidSolver::braidSolver(const std::string& objName): SolverInterface(objName) mode.dynamic = true; mode.differential = true; mode.algebraic = true; - flags[block_mode_only] = true; + flags[BLOCK_MODE_ONLY] = true; } -braidSolver::braidSolver(GridDynSimulation* gds, const solverMode& sMode): +braidSolver::braidSolver(GridDynSimulation* gds, const SolverMode& sMode): SolverInterface(gds, sMode) { } @@ -186,8 +186,8 @@ void braidSolver::allocate(count_t stateCount, count_t numRoots) deriv.resize(stateCount); state2.resize(stateCount); svsize = stateCount; - flags.reset(initialized_flag); - flags.set(allocated_flag); + flags.reset(INITIALIZED_FLAG); + flags.set(ALLOCATED_FLAG); } rootCount = numRoots; rootsfound.resize(numRoots); @@ -195,10 +195,10 @@ void braidSolver::allocate(count_t stateCount, count_t numRoots) void braidSolver::initialize(coreTime t0) { - if (!flags[allocated_flag]) { + if (!flags[ALLOCATED_FLAG]) { throw(InvalidSolverOperation(-2)); } - flags.set(initialized_flag); + flags.set(INITIALIZED_FLAG); solverCallCount = 0; solveTime = t0; diff --git a/src/extraSolvers/paradae/equations/EqGridDyn.cxx b/src/extraSolvers/paradae/equations/EqGridDyn.cxx index 398a0d9f1..7b0bcd001 100644 --- a/src/extraSolvers/paradae/equations/EqGridDyn.cxx +++ b/src/extraSolvers/paradae/equations/EqGridDyn.cxx @@ -30,7 +30,7 @@ EquationGridDyn::EquationGridDyn(Real t0_, int N_unistep_, GridDynSimulation* gds_, const Vector& y0_, - solverMode* mode_, + SolverMode* mode_, vector& discontinuities, vector& rootsfound) { diff --git a/src/extraSolvers/paradae/equations/EqGridDyn.h b/src/extraSolvers/paradae/equations/EqGridDyn.h index 4fdaa353a..c050396af 100644 --- a/src/extraSolvers/paradae/equations/EqGridDyn.h +++ b/src/extraSolvers/paradae/equations/EqGridDyn.h @@ -12,7 +12,7 @@ #include namespace griddyn { class GridDynSimulation; -class solverMode; +class SolverMode; } // namespace griddyn using namespace std; @@ -29,11 +29,11 @@ class EquationGridDyn: public Equation_DAE_full { int N_unistep_, griddyn::GridDynSimulation* gds_, const Vector& y0_, - griddyn::solverMode* mode_, + griddyn::SolverMode* mode_, vector& discontinuities, vector& rootsfound); static EquationGridDyn Default(const MapParam& param); - griddyn::solverMode* mode; //!< to the solverMode + griddyn::SolverMode* mode; //!< to the SolverMode // Redefinition of inherited virtual methods virtual void function(const Real t, diff --git a/src/fileInput/readSolverElement.cpp b/src/fileInput/readSolverElement.cpp index 4fed5f4c9..1d1a42b85 100644 --- a/src/fileInput/readSolverElement.cpp +++ b/src/fileInput/readSolverElement.cpp @@ -53,7 +53,7 @@ void loadSolverElement(std::shared_ptr& element, if (!solverIdentifier.empty()) { if (solverDefinition) { if (solverDefinition->getSolverMode().offsetIndex > - 1) // don't allow overriding the names on solvermode index 0 and 1 + 1) // don't allow overriding the names on SolverMode index 0 and 1 { solverDefinition->setName(solverIdentifier); } diff --git a/src/fmi/fmi_models/fmiCoSimLoad.cpp b/src/fmi/fmi_models/fmiCoSimLoad.cpp index aa5faa893..9c9eb9bff 100644 --- a/src/fmi/fmi_models/fmiCoSimLoad.cpp +++ b/src/fmi/fmi_models/fmiCoSimLoad.cpp @@ -58,7 +58,7 @@ void FmiCoSimLoad::dynObjectInitializeB(const IOdata& inputs, void FmiCoSimLoad::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { fmisub->setState(time, state, dstateDt, sMode); auto out = fmisub->getOutputs(noInputs, emptyStateData, cLocalSolverMode); diff --git a/src/fmi/fmi_models/fmiCoSimLoad.h b/src/fmi/fmi_models/fmiCoSimLoad.h index 8c9ef54b9..db9eeffb2 100644 --- a/src/fmi/fmi_models/fmiCoSimLoad.h +++ b/src/fmi/fmi_models/fmiCoSimLoad.h @@ -32,7 +32,7 @@ class FmiCoSimLoad: public FmiCoSimWrapper { virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; }; } // namespace griddyn::fmi diff --git a/src/fmi/fmi_models/fmiCoSimLoad3phase.cpp b/src/fmi/fmi_models/fmiCoSimLoad3phase.cpp index ddcdf9b3c..81d08e6f8 100644 --- a/src/fmi/fmi_models/fmiCoSimLoad3phase.cpp +++ b/src/fmi/fmi_models/fmiCoSimLoad3phase.cpp @@ -68,7 +68,7 @@ void FmiCoSimLoad3phase::set(std::string_view param, double val, units::unit uni void FmiCoSimLoad3phase::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { fmisub->setState(time, state, dstateDt, sMode); auto out = fmisub->getOutputs(noInputs, emptyStateData, cLocalSolverMode); diff --git a/src/fmi/fmi_models/fmiCoSimLoad3phase.h b/src/fmi/fmi_models/fmiCoSimLoad3phase.h index 36c6c9ff9..92bd270f3 100644 --- a/src/fmi/fmi_models/fmiCoSimLoad3phase.h +++ b/src/fmi/fmi_models/fmiCoSimLoad3phase.h @@ -35,7 +35,7 @@ class FmiCoSimLoad3phase: public FmiCoSimWrapper { virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual const std::vector& getFmiInputNames() const override; diff --git a/src/fmi/fmi_models/fmiCoSimSubModel.cpp b/src/fmi/fmi_models/fmiCoSimSubModel.cpp index 02f4e0e02..d9a27589f 100644 --- a/src/fmi/fmi_models/fmiCoSimSubModel.cpp +++ b/src/fmi/fmi_models/fmiCoSimSubModel.cpp @@ -417,7 +417,7 @@ double FmiCoSimSubModel::getPartial(int depIndex, int refIndex, RefMode /*mode*/ void FmiCoSimSubModel::timestep(coreTime /*time*/, const IOdata& /*inputs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { assert(unimplemented); /* @@ -472,7 +472,7 @@ void FmiCoSimSubModel::ioPartialDerivatives(const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /* md*/, const IOlocs& /*inputLocs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { assert(unimplemented); /* @@ -515,7 +515,7 @@ for (kk = 0; kk < m_outputSize; ++kk) IOdata FmiCoSimSubModel::getOutputs(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { IOdata out(m_outputSize, 0); if (cs->getCurrentMode() >= FmuMode::INITIALIZATION_MODE) { @@ -544,7 +544,7 @@ IOdata FmiCoSimSubModel::getOutputs(const IOdata& /*inputs*/, double FmiCoSimSubModel::getDoutdt(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t /*outputNum*/) const { return 0; @@ -552,7 +552,7 @@ double FmiCoSimSubModel::getDoutdt(const IOdata& /*inputs*/, double FmiCoSimSubModel::getOutput(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum) const { double out = kNullVal; @@ -585,7 +585,7 @@ double FmiCoSimSubModel::getOutput(index_t outputNum) const void FmiCoSimSubModel::updateLocalCache([[maybe_unused]] const IOdata& inputs, [[maybe_unused]] const stateData& sD, - [[maybe_unused]] const solverMode& sMode) + [[maybe_unused]] const SolverMode& sMode) { static_cast(inputs); static_cast(sD); diff --git a/src/fmi/fmi_models/fmiCoSimSubModel.h b/src/fmi/fmi_models/fmiCoSimSubModel.h index 9d5c7d902..937be3a4a 100644 --- a/src/fmi/fmi_models/fmiCoSimSubModel.h +++ b/src/fmi/fmi_models/fmiCoSimSubModel.h @@ -57,30 +57,30 @@ class FmiCoSimSubModel: public GridSubModel { virtual double get(std::string_view param, units::unit unitType = units::defunit) const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getDoutdt(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const override; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const override; virtual double getOutput(index_t outputNum = 0) const override; virtual void updateLocalCache([[maybe_unused]] const IOdata& inputs, [[maybe_unused]] const stateData& sD, - [[maybe_unused]] const solverMode& sMode) override; + [[maybe_unused]] const SolverMode& sMode) override; bool isLoaded() const; protected: diff --git a/src/fmi/fmi_models/fmiCoSimWrapper.hpp b/src/fmi/fmi_models/fmiCoSimWrapper.hpp index fc4dac179..0845ea1d7 100644 --- a/src/fmi/fmi_models/fmiCoSimWrapper.hpp +++ b/src/fmi/fmi_models/fmiCoSimWrapper.hpp @@ -41,7 +41,7 @@ class FmiCoSimWrapper: public FmiWrapper { void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override + const SolverMode& sMode) override { FmiWrapper::fmisub->residual(inputs, sD, resid, sMode); } @@ -49,7 +49,7 @@ class FmiCoSimWrapper: public FmiWrapper { void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override + const SolverMode& sMode) override { FmiWrapper::fmisub->derivative(inputs, sD, deriv, sMode); } @@ -57,7 +57,7 @@ class FmiCoSimWrapper: public FmiWrapper { void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override + const SolverMode& sMode) override { FmiWrapper::fmisub->outputPartialDerivatives(inputs, sD, @@ -68,7 +68,7 @@ class FmiCoSimWrapper: public FmiWrapper { const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override + const SolverMode& sMode) override { FmiWrapper::fmisub->ioPartialDerivatives( inputs, sD, md, inputLocs, sMode); @@ -77,7 +77,7 @@ class FmiCoSimWrapper: public FmiWrapper { const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override + const SolverMode& sMode) override { FmiWrapper::fmisub->jacobianElements( inputs, sD, md, inputLocs, sMode); @@ -86,14 +86,14 @@ class FmiCoSimWrapper: public FmiWrapper { void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override + const SolverMode& sMode) override { FmiWrapper::fmisub->rootTest(inputs, sD, roots, sMode); } void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override + const SolverMode& sMode) override { FmiWrapper::fmisub->rootTrigger(time, inputs, rootMask, sMode); } @@ -101,17 +101,17 @@ class FmiCoSimWrapper: public FmiWrapper { void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override + const SolverMode& sMode) override { FmiWrapper::fmisub->setState(time, state, dstateDt, sMode); } - index_t findIndex(std::string_view field, const solverMode& sMode) const override + index_t findIndex(std::string_view field, const SolverMode& sMode) const override { return FmiWrapper::fmisub->findIndex(field, sMode); } - void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override + void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override { BaseObj::prevTime = time; FmiWrapper::fmisub->timestep(time, inputs, sMode); diff --git a/src/fmi/fmi_models/fmiMELoad.cpp b/src/fmi/fmi_models/fmiMELoad.cpp index 4b03b6ae0..0775bd2f8 100644 --- a/src/fmi/fmi_models/fmiMELoad.cpp +++ b/src/fmi/fmi_models/fmiMELoad.cpp @@ -30,7 +30,7 @@ CoreObject* FmiMELoad::clone(CoreObject* obj) const void FmiMELoad::updateLocalCache(const IOdata& inputs, const stateData& stateDataRef, - const solverMode& sMode) + const SolverMode& sMode) { auto inputVector = inputs; const auto voltageComplex = std::polar(inputs[voltageInLocation], inputs[angleInLocation]); @@ -67,7 +67,7 @@ void FmiMELoad::set(std::string_view param, double val, units::unit unitType) void FmiMELoad::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { FmiMEWrapper::setState(time, state, dstateDt, sMode); auto out = fmisub->getOutputs(noInputs, emptyStateData, cLocalSolverMode); diff --git a/src/fmi/fmi_models/fmiMELoad.h b/src/fmi/fmi_models/fmiMELoad.h index 5c16df4b5..22bc86f2f 100644 --- a/src/fmi/fmi_models/fmiMELoad.h +++ b/src/fmi/fmi_models/fmiMELoad.h @@ -32,11 +32,11 @@ class FmiMELoad: public FmiMEWrapper { virtual void updateLocalCache(const IOdata& inputs, const stateData& stateDataRef, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; protected: IOdata translateOutput(const IOdata& fmiOutput, const IOdata& busV); diff --git a/src/fmi/fmi_models/fmiMELoad3phase.cpp b/src/fmi/fmi_models/fmiMELoad3phase.cpp index 755faf670..5828a994f 100644 --- a/src/fmi/fmi_models/fmiMELoad3phase.cpp +++ b/src/fmi/fmi_models/fmiMELoad3phase.cpp @@ -69,7 +69,7 @@ void FmiMELoad3phase::set(std::string_view param, double val, units::unit unitTy void FmiMELoad3phase::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { fmisub->setState(time, state, dstateDt, sMode); auto out = fmisub->getOutputs(noInputs, emptyStateData, cLocalSolverMode); @@ -79,7 +79,7 @@ void FmiMELoad3phase::setState(coreTime time, void FmiMELoad3phase::updateLocalCache(const IOdata& inputs, const stateData& stateDataRef, - const solverMode& sMode) + const SolverMode& sMode) { auto inputVector = opFlags[COMPLEX_VOLTAGE] ? generate3PhaseVector(inputs) : generate3PhasePolarVector(inputs); diff --git a/src/fmi/fmi_models/fmiMELoad3phase.h b/src/fmi/fmi_models/fmiMELoad3phase.h index e96917512..606baeca5 100644 --- a/src/fmi/fmi_models/fmiMELoad3phase.h +++ b/src/fmi/fmi_models/fmiMELoad3phase.h @@ -35,11 +35,11 @@ class FmiMELoad3phase: public FmiMEWrapper { virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void updateLocalCache(const IOdata& inputs, const stateData& stateDataRef, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual const std::vector& getFmiInputNames() const override; virtual const std::vector& getFmiOutputNames() const override; diff --git a/src/fmi/fmi_models/fmiMESubModel.cpp b/src/fmi/fmi_models/fmiMESubModel.cpp index 66a1a846f..b31e38d93 100644 --- a/src/fmi/fmi_models/fmiMESubModel.cpp +++ b/src/fmi/fmi_models/fmiMESubModel.cpp @@ -333,7 +333,7 @@ double FmiMESubModel::get(std::string_view param, units::unit unitType) const return GridSubModel::get(param, unitType); } -stateSizes FmiMESubModel::localStateSizes(const solverMode& sMode) const +stateSizes FmiMESubModel::localStateSizes(const SolverMode& sMode) const { stateSizes stateSizeInfo; if (hasDifferential(sMode)) { @@ -344,7 +344,7 @@ stateSizes FmiMESubModel::localStateSizes(const solverMode& sMode) const return stateSizeInfo; } -count_t FmiMESubModel::localJacobianCount(const solverMode& sMode) const +count_t FmiMESubModel::localJacobianCount(const SolverMode& sMode) const { count_t jacSize = 0; if (hasDifferential(sMode) || (!isDynamic(sMode) && opFlags[pflow_init_required])) { @@ -353,7 +353,7 @@ count_t FmiMESubModel::localJacobianCount(const solverMode& sMode) const return jacSize; } -std::pair FmiMESubModel::LocalRootCount(const solverMode& /* sMode */) const +std::pair FmiMESubModel::LocalRootCount(const SolverMode& /* sMode */) const { return {0, m_eventCount}; } @@ -361,7 +361,7 @@ std::pair FmiMESubModel::LocalRootCount(const solverMode& /* s void FmiMESubModel::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { if (hasDifferential(sMode)) { auto loc = offsets.getDiffOffset(sMode); @@ -409,7 +409,7 @@ void FmiMESubModel::setState(coreTime time, void FmiMESubModel::guessState(coreTime /*time*/, double state[], double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { if (m_stateSize == 0) { return; @@ -424,10 +424,10 @@ void FmiMESubModel::guessState(coreTime /*time*/, } } -void FmiMESubModel::getTols(double /*tols*/[], const solverMode& /*sMode*/) {} +void FmiMESubModel::getTols(double /*tols*/[], const SolverMode& /*sMode*/) {} void FmiMESubModel::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { if (hasDifferential(sMode)) { @@ -459,7 +459,7 @@ void FmiMESubModel::getStateName(stringVec& stNames, } } -index_t FmiMESubModel::findIndex(std::string_view field, const solverMode& /*sMode*/) const +index_t FmiMESubModel::findIndex(std::string_view field, const SolverMode& /*sMode*/) const { auto fmistNames = me->getStateNames(); auto fnd = std::find(fmistNames.begin(), fmistNames.end(), field); @@ -472,7 +472,7 @@ index_t FmiMESubModel::findIndex(std::string_view field, const solverMode& /*sMo void FmiMESubModel::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (hasDifferential(sMode)) { auto loc = offsets.getLocations(sD, resid, sMode, this); @@ -488,7 +488,7 @@ void FmiMESubModel::residual(const IOdata& inputs, void FmiMESubModel::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto loc = offsets.getLocations(sD, deriv, sMode, this); updateLocalCache(inputs, sD, sMode); @@ -602,7 +602,7 @@ void FmiMESubModel::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (hasDifferential(sMode)) { auto loc = offsets.getLocations(sD, sMode, this); @@ -659,7 +659,7 @@ void FmiMESubModel::jacobianElements(const IOdata& inputs, } } -void FmiMESubModel::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void FmiMESubModel::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { coreTime h = localIntegrationTime; // int sv = 0; @@ -707,7 +707,7 @@ void FmiMESubModel::ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(inputs, sD, sMode); double ich = 1.0; @@ -736,7 +736,7 @@ void FmiMESubModel::ioPartialDerivatives(const IOdata& inputs, void FmiMESubModel::outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) + const SolverMode& sMode) { auto loc = offsets.getLocations(sD, sMode, this); updateLocalCache(inputs, sD, sMode); @@ -767,7 +767,7 @@ void FmiMESubModel::outputPartialDerivatives(const IOdata& inputs, void FmiMESubModel::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(inputs, sD, sMode); auto rootOffset = offsets.getRootOffset(sMode); @@ -777,7 +777,7 @@ void FmiMESubModel::rootTest(const IOdata& inputs, void FmiMESubModel::rootTrigger(coreTime /*time*/, const IOdata& /*inputs*/, const std::vector& /*rootMask*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { me->setMode(FmuMode::EVENT_MODE); // TODO(PT): deal with the event @@ -786,7 +786,7 @@ void FmiMESubModel::rootTrigger(coreTime /*time*/, IOdata FmiMESubModel::getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { IOdata out(m_outputSize, 0); if (me->getCurrentMode() >= FmuMode::INITIALIZATION_MODE) { @@ -811,7 +811,7 @@ IOdata FmiMESubModel::getOutputs(const IOdata& inputs, double FmiMESubModel::getDoutdt(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t /*outputNum*/) const { return 0; @@ -819,7 +819,7 @@ double FmiMESubModel::getDoutdt(const IOdata& /*inputs*/, double FmiMESubModel::getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum) const { double out = kNullVal; @@ -849,14 +849,14 @@ double FmiMESubModel::getOutput(index_t outputNum) const return out; } -index_t FmiMESubModel::getOutputLoc(const solverMode& /*sMode*/, index_t /*outputNum*/) const +index_t FmiMESubModel::getOutputLoc(const SolverMode& /*sMode*/, index_t /*outputNum*/) const { return kNullLocation; } void FmiMESubModel::updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) + const SolverMode& sMode) { fmi2Boolean eventMode; fmi2Boolean terminateSim; diff --git a/src/fmi/fmi_models/fmiMESubModel.h b/src/fmi/fmi_models/fmiMESubModel.h index 93922d936..ce7d1b7a9 100644 --- a/src/fmi/fmi_models/fmiMESubModel.h +++ b/src/fmi/fmi_models/fmiMESubModel.h @@ -79,81 +79,81 @@ class FmiMESubModel: public GridSubModel { virtual double get(std::string_view param, units::unit unitType = units::defunit) const override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; virtual std::pair - LocalRootCount(const solverMode& /* sMode */) const override; + LocalRootCount(const SolverMode& /* sMode */) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + const SolverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getDoutdt(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const override; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const override; virtual double getOutput(index_t outputNum = 0) const override; - virtual index_t getOutputLoc(const solverMode& sMode, index_t outputNum = 0) const override; + virtual index_t getOutputLoc(const SolverMode& sMode, index_t outputNum = 0) const override; virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // for saving the state virtual void guessState(coreTime time, double state[], double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; - virtual void getTols(double tols[], const solverMode& sMode) override; + virtual void getTols(double tols[], const SolverMode& sMode) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix = "") const override; virtual bool isLoaded() const; virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; protected: void makeSettableState(); diff --git a/src/fmi/fmi_models/fmiMEWrapper.hpp b/src/fmi/fmi_models/fmiMEWrapper.hpp index 6777ac738..c261f66ce 100644 --- a/src/fmi/fmi_models/fmiMEWrapper.hpp +++ b/src/fmi/fmi_models/fmiMEWrapper.hpp @@ -52,7 +52,7 @@ class FmiMEWrapper: public FmiWrapper { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override + const SolverMode& sMode) override { if (FmiWrapper::fmisub == nullptr) { return; @@ -63,7 +63,7 @@ class FmiMEWrapper: public FmiWrapper { virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override + const SolverMode& sMode) override { if (FmiWrapper::fmisub == nullptr) { return; @@ -74,7 +74,7 @@ class FmiMEWrapper: public FmiWrapper { virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override + const SolverMode& sMode) override { if (FmiWrapper::fmisub == nullptr) { return; @@ -85,7 +85,7 @@ class FmiMEWrapper: public FmiWrapper { const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override + const SolverMode& sMode) override { if (FmiWrapper::fmisub == nullptr) { return; @@ -97,7 +97,7 @@ class FmiMEWrapper: public FmiWrapper { const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override + const SolverMode& sMode) override { if (FmiWrapper::fmisub == nullptr) { return; @@ -109,7 +109,7 @@ class FmiMEWrapper: public FmiWrapper { virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override + const SolverMode& sMode) override { if (FmiWrapper::fmisub == nullptr) { return; @@ -119,7 +119,7 @@ class FmiMEWrapper: public FmiWrapper { virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override + const SolverMode& sMode) override { if (FmiWrapper::fmisub == nullptr) { return; @@ -130,7 +130,7 @@ class FmiMEWrapper: public FmiWrapper { virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override + const SolverMode& sMode) override { if (FmiWrapper::fmisub == nullptr) { return; @@ -138,7 +138,7 @@ class FmiMEWrapper: public FmiWrapper { FmiWrapper::fmisub->setState(time, state, dstateDt, sMode); } - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override { if (FmiWrapper::fmisub == nullptr) { return kInvalidLocation; @@ -146,7 +146,7 @@ class FmiMEWrapper: public FmiWrapper { return FmiWrapper::fmisub->findIndex(field, sMode); } - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override { BaseObj::prevTime = time; if (FmiWrapper::fmisub == nullptr) { diff --git a/src/fmi/fmi_models/fmiWrapper.hpp b/src/fmi/fmi_models/fmiWrapper.hpp index 3a8b28355..15396d157 100644 --- a/src/fmi/fmi_models/fmiWrapper.hpp +++ b/src/fmi/fmi_models/fmiWrapper.hpp @@ -361,7 +361,7 @@ provided with the default to the regular call IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override + const SolverMode& sMode) const override { return fmisub->getOutputs(inputs, sD, sMode); } diff --git a/src/griddyn/Block.h b/src/griddyn/Block.h index 4dca70290..38db9a62f 100644 --- a/src/griddyn/Block.h +++ b/src/griddyn/Block.h @@ -102,7 +102,7 @@ class GridBlock: public GridSubModel { units::unit unitType = units::defunit) const override; // virtual void derivative(const IOdata &inputs, const stateData &sD, double deriv[], const - // solverMode &sMode); + // SolverMode &sMode); /** @brief simplifying function in place of residual since block have only one input/output @param[in] input the block input @@ -110,18 +110,18 @@ class GridBlock: public GridSubModel { otherwise ignored @param[in] stateDataValue the state data @param[out] resid the location to store the Jacobian elements - @param[in] solverModeValue the solverMode that corresponds to the state data + @param[in] solverModeValue the SolverMode that corresponds to the state data */ virtual void blockResidual(double input, double didt, const stateData& stateDataValue, double resid[], - const solverMode& solverModeValue); + const SolverMode& solverModeValue); virtual void residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; /** @brief simplifying function in place of derivative call since block have only one input/output @@ -130,33 +130,33 @@ class GridBlock: public GridSubModel { otherwise ignored @param[in] stateDataValue the state data @param[out] deriv the location to store the derivative elements - @param[in] solverModeValue the solverMode that corresponds to the state data + @param[in] solverModeValue the SolverMode that corresponds to the state data */ virtual void blockDerivative(double input, double didt, const stateData& stateDataValue, double deriv[], - const solverMode& solverModeValue); + const SolverMode& solverModeValue); virtual void derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; /** @brief simplifying function in place of algebraicUpdate call since block have only one input/output @param[in] input the block input @param[in] stateDataValue the state data @param[out] update the location to store the algebraic update elements - @param[in] solverModeValue the solverMode that corresponds to the state data + @param[in] solverModeValue the SolverMode that corresponds to the state data */ virtual void blockAlgebraicUpdate(double input, const stateData& stateDataValue, double update[], - const solverMode& solverModeValue); + const SolverMode& solverModeValue); virtual void algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& solverModeValue, + const SolverMode& solverModeValue, double alpha) override; /** @brief simplifying function in place of Jacobian elements since block have only one @@ -167,22 +167,22 @@ class GridBlock: public GridSubModel { @param[in] stateDataValue the state data @param[out] matrixDataValue the location to store the Jacobian elements @param[in] argLoc the index location of the input - @param[in] solverModeValue the solverMode that corresponds to the state data + @param[in] solverModeValue the SolverMode that corresponds to the state data */ virtual void blockJacobianElements(double input, double didt, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& solverModeValue); + const SolverMode& solverModeValue); virtual void jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; /** @brief simplifying function in place of timestep since block have only one input/output @param[in] time the time to step to @param[in] input the input argument @@ -192,33 +192,33 @@ class GridBlock: public GridSubModel { virtual void rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& solverModeValue, + const SolverMode& solverModeValue, CheckLevel level) override; // virtual void setTime(coreTime time){prevTime=time;}; virtual stringVec localStateNames() const override; /** get the single output for the block @param[in] stateDataValue the state data to use in computing the output - @param[in] solverModeValue the solverMode associated with the stateData + @param[in] solverModeValue the SolverMode associated with the stateData */ virtual double getBlockOutput(const stateData& stateDataValue, - const solverMode& solverModeValue) const; + const SolverMode& solverModeValue) const; /** get the single output for the block based on local information */ virtual double getBlockOutput() const; /** get the time derivative of the block output -should only be used for block with a differential output @param[in] stateDataValue the state data to use in computing the output - @param[in] solverModeValue the solverMode associated with the stateData + @param[in] solverModeValue the SolverMode associated with the stateData */ virtual double getBlockDoutDt(const stateData& stateDataValue, - const solverMode& solverModeValue) const; + const SolverMode& solverModeValue) const; /**get the time derivative of the block output -should only be used for block with a * differential output based on local information */ @@ -232,13 +232,13 @@ class GridBlock: public GridSubModel { @param[in] didt the time derivative of the input of the block @param[in] stateDataValue the stateData associated with a block @param[in] resid the memory location to store the residual - @param[in] solverModeValue the solverMode associated with the state Data + @param[in] solverModeValue the SolverMode associated with the state Data */ void limiterResidElements(double input, double didt, const stateData& stateDataValue, double resid[], - const solverMode& solverModeValue); + const SolverMode& solverModeValue); /** get the input that goes into the rate limiter*/ static double getRateInput(const IOdata& inputs); @@ -258,7 +258,7 @@ class GridBlock: public GridSubModel { /** generate the value to test based incoming information for the limiter*/ double getLimiterTestValue(double input, const stateData& stateDataValue, - const solverMode& solverModeValue); + const SolverMode& solverModeValue); }; /** @brief generate a shared pointer to a block based on a string input diff --git a/src/griddyn/Exciter.h b/src/griddyn/Exciter.h index 5dac03eb1..415e35249 100644 --- a/src/griddyn/Exciter.h +++ b/src/griddyn/Exciter.h @@ -58,28 +58,28 @@ class Exciter: public GridSubModel { virtual void residual(const IOdata& inputs, const stateData& stateData, double resid[], - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; virtual void derivative(const IOdata& inputs, const stateData& stateData, double deriv[], - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& stateData, matrixData& matrix, const IOlocs& inputLocs, - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; // handle the rootfinding functions virtual void rootTest(const IOdata& inputs, const stateData& stateData, double root[], - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateData, - const solverMode& solverMode, + const SolverMode& SolverMode, CheckLevel level) override; // virtual void setTime(coreTime time){prevTime=time;}; diff --git a/src/griddyn/GenModel.h b/src/griddyn/GenModel.h index e1f68f405..63532fb7e 100644 --- a/src/griddyn/GenModel.h +++ b/src/griddyn/GenModel.h @@ -57,11 +57,11 @@ class GenModel: public GridSubModel { virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getOutput(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outNum = 0) const override; virtual double getOutput(index_t outNum = 0) const override; @@ -69,15 +69,15 @@ class GenModel: public GridSubModel { const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; // TODO(phlpt): Split these into separate value and offset accessors. virtual double getFreq(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset = nullptr) const; virtual double getAngle(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset = nullptr) const; virtual const std::vector& inputNames() const override; diff --git a/src/griddyn/Generator.h b/src/griddyn/Generator.h index 0409417ec..c4b69c354 100644 --- a/src/griddyn/Generator.h +++ b/src/griddyn/Generator.h @@ -96,11 +96,11 @@ class Generator: public gridSecondary { virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; // for saving the state + const SolverMode& sMode) override; // for saving the state virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; // for initial setting of the state + const SolverMode& sMode) override; // for initial setting of the state virtual void set(std::string_view param, std::string_view val) override; virtual void @@ -115,54 +115,54 @@ class Generator: public gridSecondary { @throw unrecognizedObjectError is object is not valid*/ virtual void add(GridSubModel* obj); - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; virtual void residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; /** @brief get the current generator set point @return the current generator set point*/ virtual double getPset() const { return Pset; } virtual double getRealPower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getRealPower() const override; virtual double getReactivePower() const override; /** @brief function to set the generator capability curve @@ -177,7 +177,7 @@ class Generator: public gridSecondary { virtual IOdata predictOutputs(coreTime predictionTime, const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getAdjustableCapacityUp(coreTime time = maxTime) const override; virtual double getAdjustableCapacityDown(coreTime time = maxTime) const override; @@ -209,21 +209,21 @@ class Generator: public gridSecondary { virtual CoreObject* find(std::string_view object) const override; /** get the frequency the generator is operating at @param[in] stateDataValue the current stateData - @param[in] sMode the solvermode corresponding to the state + @param[in] sMode the SolverMode corresponding to the state @param[out] freqOffset the location of the frequency state in the sD arrays @return the current frequency the generator is operating at */ virtual double getFreq(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset = nullptr) const; /** get the internal angle of the generator @param[in] stateDataValue the current stateData - @param[in] sMode the solvermode corresponding to the state + @param[in] sMode the SolverMode corresponding to the state @param[out] angleOffset the location of the frequency state in the sD arrays @return the current angle of the generator is operating at */ virtual double getAngle(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset = nullptr) const; protected: diff --git a/src/griddyn/Governor.h b/src/griddyn/Governor.h index 6d2898f42..bc4c8abf5 100644 --- a/src/griddyn/Governor.h +++ b/src/griddyn/Governor.h @@ -64,26 +64,26 @@ class Governor: public GridSubModel { virtual void setFlag(std::string_view flag, bool val) override; virtual double get(std::string_view param, units::unit unitType = units::defunit) const override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + const SolverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual const std::vector& inputNames() const override; virtual const std::vector& outputNames() const override; diff --git a/src/griddyn/GridArea.h b/src/griddyn/GridArea.h index c27964c10..10b3f4d7f 100644 --- a/src/griddyn/GridArea.h +++ b/src/griddyn/GridArea.h @@ -137,21 +137,21 @@ class GridArea: public gridPrimary { virtual Generator* getGen(index_t x); // // dynInitializeB - virtual void setOffsets(const solverOffsets& newOffsets, const solverMode& sMode) override; - virtual void setOffset(index_t offset, const solverMode& sMode) override; + virtual void setOffsets(const solverOffsets& newOffsets, const SolverMode& sMode) override; + virtual void setOffset(index_t offset, const SolverMode& sMode) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; - virtual std::pair LocalRootCount(const solverMode& sMode) const override; + virtual std::pair LocalRootCount(const SolverMode& sMode) const override; - virtual void loadStateSizes(const solverMode& sMode) override; + virtual void loadStateSizes(const SolverMode& sMode) override; - virtual void loadJacobianSizes(const solverMode& sMode) override; + virtual void loadJacobianSizes(const SolverMode& sMode) override; - virtual void loadRootSizes(const solverMode& sMode) override; - virtual void setRootOffset(index_t Roffset, const solverMode& sMode) override; + virtual void loadRootSizes(const SolverMode& sMode) override; + virtual void setRootOffset(index_t Roffset, const SolverMode& sMode) override; protected: virtual void pFlowObjectInitializeA(coreTime time0, std::uint32_t flags) override; @@ -164,7 +164,7 @@ class GridArea: public gridPrimary { IOdata& fieldSet) override; public: - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; // TODO(phlpt): Implement this or remove it if angle updates are no longer used. /** @brief update the angles may be deprecated @@ -200,45 +200,45 @@ class GridArea: public gridPrimary { virtual void alert(CoreObject* obj, int code) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix = "") const override; - virtual void preEx(const IOdata& inputs, const stateData& sD, const solverMode& sMode) override; + virtual void preEx(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; virtual void delayedResidual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void delayedDerivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void delayedJacobian(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void delayedAlgebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; virtual ChangeCode @@ -247,22 +247,22 @@ class GridArea: public gridPrimary { virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // for identifying which variables are algebraic vs differential - virtual void getVariableType(double sdata[], const solverMode& sMode) override; - virtual void getTols(double tols[], const solverMode& sMode) override; + virtual void getVariableType(double sdata[], const SolverMode& sMode) override; + virtual void getTols(double tols[], const SolverMode& sMode) override; // dynamic simulation virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; /** @brief try to do a local converge on the solution to be replaced by the algebraic update function soon @param[in] time the time @param[in,out] state the system state @param[in,out] dstate_dt the system state derivative - @param[in] sMode the solverMode corresponding to the state + @param[in] sMode the SolverMode corresponding to the state @param[in] mode the mode to do the convergence @param[in] tol the tolerance to converge to @@ -270,28 +270,28 @@ class GridArea: public gridPrimary { virtual void converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode mode, double tol) override; virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void reset(ResetLevels level) override; // root finding functions virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; // grab information /** @brief get a vector of voltage from the attached buses @@ -303,13 +303,13 @@ class GridArea: public gridPrimary { /** @brief get a vector of voltage from the attached buses @param[out] voltages the vector to put the bus voltages @param[in] state the system state - @param[in] sMode the solverMode corresponding to the states + @param[in] sMode the SolverMode corresponding to the states @param[in] start the index into the vector V to start the voltage states from this area @return an index where the last value was placed */ count_t getVoltage(std::vector& voltages, const double state[], - const solverMode& sMode, + const SolverMode& sMode, index_t start = 0) const; /** @brief get a vector of angles from the attached buses @param[out] angles the vector to put the bus angles @@ -328,13 +328,13 @@ class GridArea: public gridPrimary { /** @brief get a vector of angles from the attached buses @param[out] angles the vector to put the bus angles @param[in] state the system state - @param[in] sMode the solverMode corresponding to the states + @param[in] sMode the SolverMode corresponding to the states @param[in] start the index into the vector V to start the angle states from this area @return an index where the last value was placed */ count_t getAngle(std::vector& angles, const double state[], - const solverMode& sMode, + const SolverMode& sMode, index_t start = 0) const; /** @brief get a vector of real power from the attached links @param[out] powers the vector to put the link real powers @@ -442,10 +442,10 @@ class GridArea: public gridPrimary { double getAvgAngle() const; /** @brief get the average angle for the area @param[in] sD the state data - @param[in] sMode the solverMode corresponding to the state data + @param[in] sMode the SolverMode corresponding to the state data @return the average angle */ - double getAvgAngle(const stateData& sD, const solverMode& sMode) const; + double getAvgAngle(const stateData& sD, const SolverMode& sMode) const; /** @brief get the average frequency for the area @return the average frequency @@ -461,9 +461,9 @@ class GridArea: public gridPrimary { *@param[out] vStates a vector with a value of 1.0 for all voltage states and 0 otherwise * */ - void getVoltageStates(double vStates[], const solverMode& sMode) const; - void getAngleStates(double aStates[], const solverMode& sMode) const; - double getMasterAngle(const stateData& sD, const solverMode& sMode) const; + void getVoltageStates(double vStates[], const SolverMode& sMode) const; + void getAngleStates(double aStates[], const SolverMode& sMode) const; + double getMasterAngle(const stateData& sD, const SolverMode& sMode) const; virtual void updateFlags(bool dynOnly = false) override; /** @brief get a vector of all the buses of the area @param[out] busVector a vector of buses diff --git a/src/griddyn/GridBus.h b/src/griddyn/GridBus.h index aa024a1d8..96d732d42 100644 --- a/src/griddyn/GridBus.h +++ b/src/griddyn/GridBus.h @@ -176,39 +176,39 @@ class GridBus: public gridPrimary { units::unit unitType = units::defunit) const override; // solver functions - virtual void preEx(const IOdata& inputs, const stateData& sD, const solverMode& sMode) override; + virtual void preEx(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; /** do an update on the voltage similar to the algebraic update function but only looking at voltage @param[in] sD the state data to update @param[out] update the location to place the computed update - @param[in] sMode the solverMode associated with the state data + @param[in] sMode the SolverMode associated with the state data @param[in] alpha the scale associated with the update */ virtual void - voltageUpdate(const stateData& sD, double update[], const solverMode& sMode, double alpha); + voltageUpdate(const stateData& sD, double update[], const SolverMode& sMode, double alpha); virtual void converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode = ConvergeMode::high_error_only, double tol = 0.01) override; @@ -218,10 +218,10 @@ class GridBus: public gridPrimary { virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; public: - void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; /** @brief a faster function to set the voltage and angle of a bus* @param[in] Vnew the new voltage @@ -381,8 +381,8 @@ class GridBus: public gridPrimary { virtual IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; - virtual IOlocs getOutputLocs(const solverMode& sMode) const override; + const SolverMode& sMode) const override; + virtual IOlocs getOutputLocs(const SolverMode& sMode) const override; /** @brief get a const ref to the outputs*/ const IOdata& getOutputsRef() const; @@ -392,53 +392,53 @@ class GridBus: public gridPrimary { virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outNum = 0) const override; virtual double getOutput(index_t outNum = 0) const override; /** @brief get the voltage * @param[in] state the system state - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the sbus voltage **/ - virtual double getVoltage(const double state[], const solverMode& sMode) const; + virtual double getVoltage(const double state[], const SolverMode& sMode) const; /** @brief get the angle * @param[in] state the system state - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the bus angle **/ - virtual double getAngle(const double state[], const solverMode& sMode) const; + virtual double getAngle(const double state[], const SolverMode& sMode) const; /** @brief get the voltage * @param[in] sD the system state data - @param[in] sMode the corresponding solverMode to the state data + @param[in] sMode the corresponding SolverMode to the state data @return the bus voltage **/ - virtual double getVoltage(const stateData& sD, const solverMode& sMode) const; + virtual double getVoltage(const stateData& sD, const SolverMode& sMode) const; /** @brief get the angle * @param[in] sD the system state data - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the bus angle **/ - virtual double getAngle(const stateData& sD, const solverMode& sMode) const; + virtual double getAngle(const stateData& sD, const SolverMode& sMode) const; /** @brief get the bus frequency * @param[in] sD the system state data - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the bus frequency **/ - virtual double getFreq(const stateData& sD, const solverMode& sMode) const; + virtual double getFreq(const stateData& sD, const SolverMode& sMode) const; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; friend bool compareBus(GridBus* bus1, GridBus* bus2, bool cmpValues, bool printDiff); @@ -468,10 +468,10 @@ class GridBus: public gridPrimary { protected: /** @brief compute the current power-balance error @param[in] sD the stateData to compute the error for - @param[in] sMode the solverMode corresponding to the stateData + @param[in] sMode the SolverMode corresponding to the stateData @return the error in the power balance equations */ - virtual double computeError(const stateData& sD, const solverMode& sMode); + virtual double computeError(const stateData& sD, const SolverMode& sMode); private: template diff --git a/src/griddyn/GridComponent.cpp b/src/griddyn/GridComponent.cpp index f21147ca4..932845ae4 100644 --- a/src/griddyn/GridComponent.cpp +++ b/src/griddyn/GridComponent.cpp @@ -212,7 +212,7 @@ void GridComponent::dynObjectInitializeB(const IOdata& inputs, } } -count_t GridComponent::stateSize(const solverMode& sMode) +count_t GridComponent::stateSize(const SolverMode& sMode) { const auto& solverOffsetsValue = offsets.getOffsets(sMode); if (!(solverOffsetsValue.stateLoaded)) { @@ -228,7 +228,7 @@ count_t GridComponent::stateSize(const solverMode& sMode) return ssize; } -count_t GridComponent::stateSize(const solverMode& sMode) const +count_t GridComponent::stateSize(const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); count_t ssize = (hasAlgebraic(sMode)) ? @@ -241,7 +241,7 @@ count_t GridComponent::stateSize(const solverMode& sMode) const return ssize; } -count_t GridComponent::totalAlgSize(const solverMode& sMode) +count_t GridComponent::totalAlgSize(const SolverMode& sMode) { auto& solverOffsetsValue = offsets.getOffsets(sMode); if (!(solverOffsetsValue.stateLoaded)) { @@ -251,14 +251,14 @@ count_t GridComponent::totalAlgSize(const solverMode& sMode) solverOffsetsValue.total.aSize; } -count_t GridComponent::totalAlgSize(const solverMode& sMode) const +count_t GridComponent::totalAlgSize(const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); return (solverOffsetsValue.total.algSize + solverOffsetsValue.total.vSize + solverOffsetsValue.total.aSize); } -count_t GridComponent::algSize(const solverMode& sMode) +count_t GridComponent::algSize(const SolverMode& sMode) { auto& solverOffsetsValue = offsets.getOffsets(sMode); if (!(solverOffsetsValue.stateLoaded)) { @@ -267,13 +267,13 @@ count_t GridComponent::algSize(const solverMode& sMode) return solverOffsetsValue.total.algSize; } -count_t GridComponent::algSize(const solverMode& sMode) const +count_t GridComponent::algSize(const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); return solverOffsetsValue.total.algSize; } -count_t GridComponent::diffSize(const solverMode& sMode) +count_t GridComponent::diffSize(const SolverMode& sMode) { auto& solverOffsetsValue = offsets.getOffsets(sMode); if (!(solverOffsetsValue.stateLoaded)) { @@ -282,13 +282,13 @@ count_t GridComponent::diffSize(const solverMode& sMode) return solverOffsetsValue.total.diffSize; } -count_t GridComponent::diffSize(const solverMode& sMode) const +count_t GridComponent::diffSize(const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); return solverOffsetsValue.total.diffSize; } -count_t GridComponent::rootSize(const solverMode& sMode) +count_t GridComponent::rootSize(const SolverMode& sMode) { auto& solverOffsetsValue = offsets.getOffsets(sMode); if (!(solverOffsetsValue.rootsLoaded)) { @@ -297,14 +297,14 @@ count_t GridComponent::rootSize(const solverMode& sMode) return solverOffsetsValue.total.algRoots + solverOffsetsValue.total.diffRoots; } -count_t GridComponent::rootSize(const solverMode& sMode) const +count_t GridComponent::rootSize(const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); return solverOffsetsValue.total.algRoots + solverOffsetsValue.total.diffRoots; } -count_t GridComponent::jacSize(const solverMode& sMode) +count_t GridComponent::jacSize(const SolverMode& sMode) { auto& solverOffsetsValue = offsets.getOffsets(sMode); if (!(solverOffsetsValue.jacobianLoaded)) { @@ -313,13 +313,13 @@ count_t GridComponent::jacSize(const solverMode& sMode) return solverOffsetsValue.total.jacSize; } -count_t GridComponent::jacSize(const solverMode& sMode) const +count_t GridComponent::jacSize(const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); return solverOffsetsValue.total.jacSize; } -count_t GridComponent::voltageStateCount(const solverMode& sMode) +count_t GridComponent::voltageStateCount(const SolverMode& sMode) { auto& solverOffsetsValue = offsets.getOffsets(sMode); if (!(solverOffsetsValue.stateLoaded)) { @@ -328,13 +328,13 @@ count_t GridComponent::voltageStateCount(const solverMode& sMode) return solverOffsetsValue.total.vSize; } -count_t GridComponent::voltageStateCount(const solverMode& sMode) const +count_t GridComponent::voltageStateCount(const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); return solverOffsetsValue.total.vSize; } -count_t GridComponent::angleStateCount(const solverMode& sMode) +count_t GridComponent::angleStateCount(const SolverMode& sMode) { auto& solverOffsetsValue = offsets.getOffsets(sMode); if (!(solverOffsetsValue.stateLoaded)) { @@ -343,18 +343,18 @@ count_t GridComponent::angleStateCount(const solverMode& sMode) return solverOffsetsValue.total.aSize; } -count_t GridComponent::angleStateCount(const solverMode& sMode) const +count_t GridComponent::angleStateCount(const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); return solverOffsetsValue.total.aSize; } -const solverOffsets& GridComponent::getOffsets(const solverMode& sMode) const +const solverOffsets& GridComponent::getOffsets(const SolverMode& sMode) const { return offsets.getOffsets(sMode); } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::setOffsets(const solverOffsets& newOffsets, const solverMode& sMode) +void GridComponent::setOffsets(const solverOffsets& newOffsets, const SolverMode& sMode) { offsets.setOffsets(newOffsets, sMode); @@ -371,7 +371,7 @@ void GridComponent::setOffsets(const solverOffsets& newOffsets, const solverMode } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::setOffset(index_t newOffset, const solverMode& sMode) +void GridComponent::setOffset(index_t newOffset, const SolverMode& sMode) { if (!subObjectList.empty()) { for (auto& subobj : subObjectList) { @@ -384,17 +384,17 @@ void GridComponent::setOffset(index_t newOffset, const solverMode& sMode) offsets.setOffset(newOffset, sMode); } -bool GridComponent::isStateCountLoaded(const solverMode& sMode) const +bool GridComponent::isStateCountLoaded(const SolverMode& sMode) const { return offsets.isStateCountLoaded(sMode); } -bool GridComponent::isJacobianCountLoaded(const solverMode& sMode) const +bool GridComponent::isJacobianCountLoaded(const SolverMode& sMode) const { return offsets.isJacobianCountLoaded(sMode); } -bool GridComponent::isRootCountLoaded(const solverMode& sMode) const +bool GridComponent::isRootCountLoaded(const SolverMode& sMode) const { return offsets.isRootCountLoaded(sMode); } @@ -548,7 +548,7 @@ bool GridComponent::checkFlag(index_t flagID) const { return opFlags.test(flagID); } -bool GridComponent::hasStates(const solverMode& sMode) const +bool GridComponent::hasStates(const SolverMode& sMode) const { return (stateSize(sMode) > 0); } @@ -922,7 +922,7 @@ ChangeCode void GridComponent::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { prevTime = time; if (!hasStates(sMode)) // use the const version of stateSize @@ -967,7 +967,7 @@ void GridComponent::setState(coreTime time, void GridComponent::guessState(coreTime time, double state[], double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { if (!hasStates(sMode)) { return; @@ -1061,7 +1061,7 @@ double GridComponent::getState(index_t offset) const } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::loadSizesSub(const solverMode& sMode, SizeCategory category) +void GridComponent::loadSizesSub(const SolverMode& sMode, SizeCategory category) { auto& solverOffsetsValue = offsets.getOffsets(sMode); switch (category) { @@ -1114,24 +1114,24 @@ void GridComponent::loadSizesSub(const solverMode& sMode, SizeCategory category) } } -stateSizes GridComponent::localStateSizes(const solverMode& /*sMode*/) const +stateSizes GridComponent::localStateSizes(const SolverMode& /*sMode*/) const { return offsets.local().local; } -count_t GridComponent::localJacobianCount(const solverMode& /*sMode*/) const +count_t GridComponent::localJacobianCount(const SolverMode& /*sMode*/) const { return offsets.local().local.jacSize; } -std::pair GridComponent::LocalRootCount(const solverMode& /*sMode*/) const +std::pair GridComponent::LocalRootCount(const SolverMode& /*sMode*/) const { const auto& localCounts = offsets.local().local; return std::make_pair(localCounts.algRoots, localCounts.diffRoots); } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::loadStateSizes(const solverMode& sMode) +void GridComponent::loadStateSizes(const SolverMode& sMode) { if (isStateCountLoaded(sMode)) { return; @@ -1187,7 +1187,7 @@ void GridComponent::loadStateSizes(const solverMode& sMode) } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::loadRootSizes(const solverMode& sMode) +void GridComponent::loadRootSizes(const SolverMode& sMode) { if (isRootCountLoaded(sMode)) { return; @@ -1233,7 +1233,7 @@ void GridComponent::loadRootSizes(const solverMode& sMode) } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::loadJacobianSizes(const solverMode& sMode) +void GridComponent::loadJacobianSizes(const SolverMode& sMode) { if (isJacobianCountLoaded(sMode)) { return; @@ -1265,7 +1265,7 @@ void GridComponent::loadJacobianSizes(const solverMode& sMode) } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::getTols(double tols[], const solverMode& sMode) +void GridComponent::getTols(double tols[], const SolverMode& sMode) { for (auto& subObj : subObjectList) { if (subObj->isEnabled()) { @@ -1275,7 +1275,7 @@ void GridComponent::getTols(double tols[], const solverMode& sMode) } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::getVariableType(double sdata[], const solverMode& sMode) +void GridComponent::getVariableType(double sdata[], const SolverMode& sMode) { auto& solverOffsetsValue = offsets.getOffsets(sMode); if (subObjectList.empty()) { @@ -1371,7 +1371,7 @@ void GridComponent::alert(CoreObject* object, int code) } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::getConstraints(double constraints[], const solverMode& sMode) +void GridComponent::getConstraints(double constraints[], const SolverMode& sMode) { for (auto& subobj : subObjectList) { if ((subobj->isEnabled()) && (subobj->checkFlag(has_constraints))) { @@ -1381,7 +1381,7 @@ void GridComponent::getConstraints(double constraints[], const solverMode& sMode } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::setRootOffset(index_t newRootOffset, const solverMode& sMode) +void GridComponent::setRootOffset(index_t newRootOffset, const SolverMode& sMode) { offsets.setRootOffset(newRootOffset, sMode); auto& solverOffsetsValue = offsets.getOffsets(sMode); @@ -1462,7 +1462,7 @@ units::unit GridComponent::outputUnits(index_t /*outputNum*/) const } // NOLINTNEXTLINE(misc-no-recursion) -index_t GridComponent::findIndex(std::string_view field, const solverMode& sMode) const +index_t GridComponent::findIndex(std::string_view field, const SolverMode& sMode) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); if (field.starts_with("state")) { @@ -1537,7 +1537,7 @@ index_t GridComponent::findIndex(std::string_view field, const solverMode& sMode // NOLINTNEXTLINE(misc-no-recursion) void GridComponent::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { const auto& solverOffsetsValue = offsets.getOffsets(sMode); @@ -1636,7 +1636,7 @@ void GridComponent::updateFlags(bool dynamicsFlags) // NOLINTNEXTLINE(misc-no-recursion) void GridComponent::updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& sub : subObjectList) { sub->updateLocalCache(inputs, stateDataValue, sMode); @@ -1687,7 +1687,7 @@ CoreObject* GridComponent::findByUserID(std::string_view typeName, index_t searc } // NOLINTNEXTLINE(misc-no-recursion) -void GridComponent::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void GridComponent::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { prevTime = time; @@ -1704,7 +1704,7 @@ void GridComponent::ioPartialDerivatives(const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /*md*/, const IOlocs& /*inputLocs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { /* there is no way to determine partial derivatives of the output with respect to input in a default manner therefore the default is no dependencies @@ -1714,7 +1714,7 @@ void GridComponent::ioPartialDerivatives(const IOdata& /*inputs*/, void GridComponent::outputPartialDerivatives(const IOdata& /*inputs*/, const stateData& /*stateDataValue*/, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { /* assume the output is a state and compute accordingly*/ for (index_t kk = 0; kk < m_outputSize; ++kk) { @@ -1723,7 +1723,7 @@ void GridComponent::outputPartialDerivatives(const IOdata& /*inputs*/, } } -count_t GridComponent::outputDependencyCount(index_t outputNum, const solverMode& sMode) const +count_t GridComponent::outputDependencyCount(index_t outputNum, const SolverMode& sMode) const { /* assume the output is a state and act accordingly*/ @@ -1734,7 +1734,7 @@ count_t GridComponent::outputDependencyCount(index_t outputNum, const solverMode // NOLINTNEXTLINE(misc-no-recursion) void GridComponent::preEx(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& subobj : subObjectList) { if (!(subobj->checkFlag(preEx_requested))) { @@ -1750,7 +1750,7 @@ void GridComponent::preEx(const IOdata& inputs, void GridComponent::residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { for (auto& sub : subObjectList) { if (!sub->checkFlag(separate_processing)) { @@ -1765,7 +1765,7 @@ void GridComponent::residual(const IOdata& inputs, void GridComponent::derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { for (auto& sub : subObjectList) { if (!sub->checkFlag(separate_processing)) { @@ -1780,7 +1780,7 @@ void GridComponent::derivative(const IOdata& inputs, void GridComponent::algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { for (auto& sub : subObjectList) { @@ -1797,7 +1797,7 @@ void GridComponent::jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& sub : subObjectList) { if (!sub->checkFlag(separate_processing)) { @@ -1811,7 +1811,7 @@ void GridComponent::jacobianElements(const IOdata& inputs, void GridComponent::rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { for (auto& subobj : subObjectList) { if (!subobj->checkFlag(separate_processing)) { @@ -1827,7 +1827,7 @@ void GridComponent::rootTest(const IOdata& inputs, void GridComponent::rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& subobj : subObjectList) { if (!(subobj->checkFlag(has_roots))) { @@ -1842,7 +1842,7 @@ void GridComponent::rootTrigger(coreTime time, // NOLINTNEXTLINE(misc-no-recursion) ChangeCode GridComponent::rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { auto ret = ChangeCode::NO_CHANGE; @@ -1884,7 +1884,7 @@ index_t GridComponent::lookupOutputIndex(std::string_view outputName) const double GridComponent::getOutput(const IOdata& /*inputs*/, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum) const { if (outputNum >= m_outputSize) { @@ -1918,7 +1918,7 @@ double GridComponent::getOutput(index_t outputNum) const IOdata GridComponent::getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { IOdata mout(m_outputSize); for (count_t pp = 0; pp < m_outputSize; ++pp) { @@ -1931,7 +1931,7 @@ IOdata GridComponent::getOutputs(const IOdata& inputs, double GridComponent::getDoutdt(const IOdata& /*inputs*/, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum) const { if (outputNum >= m_outputSize) { @@ -1953,7 +1953,7 @@ double GridComponent::getDoutdt(const IOdata& /*inputs*/, return 0.0; } -index_t GridComponent::getOutputLoc(const solverMode& sMode, index_t outputNum) const +index_t GridComponent::getOutputLoc(const SolverMode& sMode, index_t outputNum) const { if (outputNum >= m_outputSize) { return kNullLocation; @@ -1978,7 +1978,7 @@ index_t GridComponent::getOutputLoc(const solverMode& sMode, index_t outputNum) return kNullLocation; } -IOlocs GridComponent::getOutputLocs(const solverMode& sMode) const +IOlocs GridComponent::getOutputLocs(const SolverMode& sMode) const { IOlocs oloc(m_outputSize); @@ -2007,7 +2007,7 @@ void GridComponent::parameterPartialDerivatives(index_t param, const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /*md*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { throw(UnrecognizedParameter("param" + std::to_string(param))); } @@ -2017,12 +2017,12 @@ double GridComponent::parameterOutputPartialDerivatives(index_t param, index_t /*outputNum*/, const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { throw(UnrecognizedParameter("param" + std::to_string(param))); } -void printStateNames(const GridComponent* comp, const solverMode& sMode) +void printStateNames(const GridComponent* comp, const SolverMode& sMode) { auto ssize = comp->stateSize(sMode); std::vector sNames(ssize); diff --git a/src/griddyn/GridComponent.h b/src/griddyn/GridComponent.h index de7a350ed..60c0d3b29 100644 --- a/src/griddyn/GridComponent.h +++ b/src/griddyn/GridComponent.h @@ -202,13 +202,13 @@ see GridComponent::dynInitializeA for more details @param[in] newOffset the offset index all variables are sequential. @param sMode the solver mode to use. */ - virtual void setOffset(index_t newOffset, const solverMode& sMode); + virtual void setOffset(index_t newOffset, const SolverMode& sMode); /** @brief set the offsets of an object for a particular solver mode using a single offset. @param newOffsets the offset index all variables are sequential. @param sMode the solver mode to use. */ - virtual void setOffsets(const solverOffsets& newOffsets, const solverMode& sMode); + virtual void setOffsets(const solverOffsets& newOffsets, const SolverMode& sMode); /** @brief get a single state value @param offset the offset index: all state variables are sequential. @@ -226,93 +226,93 @@ see GridComponent::dynInitializeA for more details @param[in] newRootOffset the offset index all variables are sequential. @param[in] sMode the solver mode to use. */ - virtual void setRootOffset(index_t newRootOffset, const solverMode& sMode); + virtual void setRootOffset(index_t newRootOffset, const SolverMode& sMode); /** @brief get the number of states - @param[in] sMode the solverMode to get the stateSize for + @param[in] sMode the SolverMode to get the stateSize for @return the number of states */ - count_t stateSize(const solverMode& sMode); + count_t stateSize(const SolverMode& sMode); /** @brief get the total number of Algebraic States algSize+vSize+aSize - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of algebraic states */ - count_t totalAlgSize(const solverMode& sMode); + count_t totalAlgSize(const SolverMode& sMode); /** @brief get the number of Jacobian non-zeros elements (max not necessarily actual) - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of non-zeros in the Jacobian */ - count_t jacSize(const solverMode& sMode); + count_t jacSize(const SolverMode& sMode); /** @brief get the number of roots - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of roots */ - count_t rootSize(const solverMode& sMode); + count_t rootSize(const SolverMode& sMode); /** @brief get the number of algebraic states not including voltage and angle states - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of algebraic states */ - count_t algSize(const solverMode& sMode); + count_t algSize(const SolverMode& sMode); /** @brief get the number of differential states - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of differential states */ - count_t diffSize(const solverMode& sMode); + count_t diffSize(const SolverMode& sMode); /** @brief get the number of voltage states - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of voltage states */ - count_t voltageStateCount(const solverMode& sMode); + count_t voltageStateCount(const SolverMode& sMode); /** @brief get the number of angle states - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of angle states */ - count_t angleStateCount(const solverMode& sMode); + count_t angleStateCount(const SolverMode& sMode); /** @brief get the number of states - @param[in] sMode the solverMode to get the stateSize for + @param[in] sMode the SolverMode to get the stateSize for @return the number of states */ - count_t stateSize(const solverMode& sMode) const; + count_t stateSize(const SolverMode& sMode) const; /** @brief get the total number of Algebraic States algSize+vSize+aSize - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of algebraic states */ - count_t totalAlgSize(const solverMode& sMode) const; + count_t totalAlgSize(const SolverMode& sMode) const; /** @brief get the number of Jacobian non-zeros elements (max not necessarily actual) - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of non-zeros in the Jacobian */ - count_t jacSize(const solverMode& sMode) const; + count_t jacSize(const SolverMode& sMode) const; /** @brief get the number of roots - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of roots */ - count_t rootSize(const solverMode& sMode) const; + count_t rootSize(const SolverMode& sMode) const; /** @brief get the number of algebraic states not including voltage and angle states - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of algebraic states */ - count_t algSize(const solverMode& sMode) const; + count_t algSize(const SolverMode& sMode) const; /** @brief get the number of differential states - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of differential states */ - count_t diffSize(const solverMode& sMode) const; + count_t diffSize(const SolverMode& sMode) const; /** @brief get the number of voltage states - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of voltage states */ - count_t voltageStateCount(const solverMode& sMode) const; + count_t voltageStateCount(const SolverMode& sMode) const; /** @brief get the number of angle states - @param[in] sMode solverMode to base the count on + @param[in] sMode SolverMode to base the count on @return the number of angle states */ - count_t angleStateCount(const solverMode& sMode) const; + count_t angleStateCount(const SolverMode& sMode) const; /** @brief get the number of outputs @return the number of outputs @@ -327,35 +327,35 @@ see GridComponent::dynInitializeA for more details * @param[in] sMode the mode to get the offsets for * return a const pointer to the solver Offsets */ - const solverOffsets& getOffsets(const solverMode& sMode) const; + const solverOffsets& getOffsets(const SolverMode& sMode) const; /** @brief checks if the object state sizes are loaded - @param[in] sMode the solverMode to get the stateSize for + @param[in] sMode the SolverMode to get the stateSize for @return boolean true if the object is loaded false if not */ - bool isStateCountLoaded(const solverMode& sMode) const; + bool isStateCountLoaded(const SolverMode& sMode) const; /** @brief checks if the object state sizes are loaded - @param[in] sMode the solverMode to get the stateSize for + @param[in] sMode the SolverMode to get the stateSize for @return boolean true if the object is loaded false if not */ - bool isJacobianCountLoaded(const solverMode& sMode) const; + bool isJacobianCountLoaded(const SolverMode& sMode) const; /** @brief checks if the object state sizes are loaded - @param[in] sMode the solverMode to get the stateSize for + @param[in] sMode the SolverMode to get the stateSize for @return boolean true if the object is loaded false if not */ - bool isRootCountLoaded(const solverMode& sMode) const; + bool isRootCountLoaded(const SolverMode& sMode) const; /** @brief convenience function for checking armed status @return boolean true if the object is armed false if not */ bool isArmed() const; virtual bool isCloneable() const override; /** @brief convenience function for checking if the object has states - @param[in] sMode the solverMode to check + @param[in] sMode the SolverMode to check @return boolean true if the object is armed false if not */ - bool hasStates(const solverMode& sMode) const; + bool hasStates(const SolverMode& sMode) const; /** @brief function for checking connected status @return boolean true if the object is connect false if not @@ -380,33 +380,33 @@ see GridComponent::dynInitializeA for more details @param sMode the solver mode to use. @return a stateSizes object containing the various segment sizes */ - virtual stateSizes localStateSizes(const solverMode& sMode) const; + virtual stateSizes localStateSizes(const SolverMode& sMode) const; /** @brief compute the local Jacobian count @param sMode the solver mode to use. @return a stateSizes object containing the various segment sizes */ - virtual count_t localJacobianCount(const solverMode& sMode) const; + virtual count_t localJacobianCount(const SolverMode& sMode) const; /** @brief compute the local root count @param sMode the solver mode to use. @return a pair containing the local root counts */ - virtual std::pair LocalRootCount(const solverMode& sMode) const; + virtual std::pair LocalRootCount(const SolverMode& sMode) const; /** @brief compute the sizes and store them in the offsetTables. @param sMode the solver mode to use. */ - virtual void loadStateSizes(const solverMode& sMode); + virtual void loadStateSizes(const SolverMode& sMode); /** @brief compute the sizes and store them in the offsetTables. @param sMode the solver mode to use. */ - virtual void loadJacobianSizes(const solverMode& sMode); + virtual void loadJacobianSizes(const SolverMode& sMode); /** @brief compute the sizes and store them in the offsetTables. @param sMode the solver mode to use. */ - virtual void loadRootSizes(const solverMode& sMode); + virtual void loadRootSizes(const SolverMode& sMode); protected: enum class SizeCategory { @@ -418,7 +418,7 @@ see GridComponent::dynInitializeA for more details @param sMode the solver mode to use. @param category set to the type of size data being loaded */ - void loadSizesSub(const solverMode& sMode, SizeCategory category); + void loadSizesSub(const SolverMode& sMode, SizeCategory category); public: /** @brief reset the object @@ -432,31 +432,31 @@ see GridComponent::dynInitializeA for more details @param state -- a double array pointing to the state information @param dstateDt a double array pointing to the state derivative information (not necessary for states with no corresponding time derivative - @param sMode -- the solverMode corresponding to the computed state. + @param sMode -- the SolverMode corresponding to the computed state. */ virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode); + const SolverMode& sMode); /** @brief transfer state information from the objects to a vector @param time -the time the state corresponds to @param[out] state -- a double array pointing to the state information @param[out] dstateDt a double array pointing to the state derivative information (not necessary for states with no corresponding time derivative - @param sMode -- the solverMode corresponding to the computed state. + @param sMode -- the SolverMode corresponding to the computed state. */ virtual void - guessState(coreTime time, double state[], double dstateDt[], const solverMode& sMode); + guessState(coreTime time, double state[], double dstateDt[], const SolverMode& sMode); /** @brief load tolerance information from the objects @param[out] tols -- a double array with the state tolerance information - @param[in] sMode -- the solverMode corresponding to the computed state. + @param[in] sMode -- the SolverMode corresponding to the computed state. */ - virtual void getTols(double tols[], const solverMode& sMode); + virtual void getTols(double tols[], const SolverMode& sMode); /** @brief load variable information 1 for algebraic state 0 for differential state @param[out] sdata -- a double array with the state tolerance information - @param[in] sMode -- the solverMode corresponding to the computed state. + @param[in] sMode -- the SolverMode corresponding to the computed state. */ - virtual void getVariableType(double sdata[], const solverMode& sMode); + virtual void getVariableType(double sdata[], const SolverMode& sMode); /**@brief get a reference to the vector of subObjects*/ const objVector& getSubObjects() const { return subObjectList; } @@ -467,9 +467,9 @@ see GridComponent::dynInitializeA for more details 2 for >=0 -2 for <=0 @param[out] constraints -- a double array with the constraint - @param[in] sMode -- the solverMode corresponding to the computed state. + @param[in] sMode -- the SolverMode corresponding to the computed state. */ - virtual void getConstraints(double constraints[], const solverMode& sMode); + virtual void getConstraints(double constraints[], const SolverMode& sMode); /** @brief update cascading flag information @param[in] dynamicsFlags if true only do so for flags corresponding to dynamic solution */ @@ -477,29 +477,29 @@ see GridComponent::dynInitializeA for more details /** @brief get the names for all the states @param[out] stNames -- the output state names - @param[in] sMode -- the solverMode corresponding to the computed state. + @param[in] sMode -- the SolverMode corresponding to the computed state. @param[in] prefix a string prefix to put before the state names of the object-- intended for cascading calls */ virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix = "") const; /**brief update any local cached information about a particular state/input set @param[in] inputs the input inputs @param[in] stateDataValue the stage data to cache information from - @param[in] sMode the solverMode corresponding to the stateData + @param[in] sMode the SolverMode corresponding to the stateData */ virtual void updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode); + const SolverMode& sMode); /** @brief locate a state index based on field name @param[in] field the name of the field to search for - @param[in] sMode the solverMode to find the location for + @param[in] sMode the SolverMode to find the location for @return the index of the state some number if valid kInvalidLocation if not found, kNullLocation if not initialized yet(try again later) */ - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const; /** *@brief set all the values of particular type of object to some value @@ -553,37 +553,37 @@ see GridComponent::dynInitializeA for more details @param[in] inputs the input arguments @param[in] stateDataValue the data representing the current state to operate on @param[out] resid the array to store the residual values in - @param[in] sMode the solverMode which is being solved for + @param[in] sMode the SolverMode which is being solved for */ virtual void residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode); + const SolverMode& sMode); /** @brief compute an update to all the algebraic variables in the object @param[in] inputs the input arguments @param[in] stateDataValue the data representing the current state to operate on @param[out] update the array to store the computed state values - @param[in] sMode the solverMode which is being solved for + @param[in] sMode the SolverMode which is being solved for @param[in] alpha the convergence gain */ virtual void algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha); /** @brief compute the time derivative for a given state @param[in] inputs the input arguments @param[in] stateDataValue the data representing the current state to operate on @param[out] deriv the array to store the computed derivative values - @param[in] sMode the solverMode which is being solved for + @param[in] sMode the SolverMode which is being solved for */ virtual void derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode); + const SolverMode& sMode); /** *@brief compute the partial derivatives of the internal states with respect to inputs and other internal states @@ -597,7 +597,7 @@ see GridComponent::dynInitializeA for more details const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode); + const SolverMode& sMode); // for the stepwise dynamic system /** @brief move the object forward in time using local calculations @@ -605,10 +605,10 @@ see GridComponent::dynInitializeA for more details necessarily indicative of a particular solver it is meant as a suggestion not a requirement. @param[in] time the time to progress to @param[in] inputs the input arguments - @param[in] sMode the solverMode to give guidance to objects on how to perform internal + @param[in] sMode the SolverMode to give guidance to objects on how to perform internal calculations */ - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode); + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode); /** *@brief compute the partial derivatives of the output states with respect to internal states @@ -620,14 +620,14 @@ see GridComponent::dynInitializeA for more details virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode); + const SolverMode& sMode); /** @brief return the count of output dependencies on internal states @param[in] outputNum the index of the output to query @param[in] sMode the solver mode to consider @return the count of the output Dependencies */ - virtual count_t outputDependencyCount(index_t outputNum, const solverMode& sMode) const; + virtual count_t outputDependencyCount(index_t outputNum, const SolverMode& sMode) const; /** * @brief compute the partial derivatives of the output states with respect to inputs * @param[in] inputs the inputs for the secondary object @@ -640,7 +640,7 @@ see GridComponent::dynInitializeA for more details const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode); + const SolverMode& sMode); /** @brief call any objects that need 2 part execution to allow for parallelism do any pre-work for a residual call later in the calculations @@ -649,10 +649,10 @@ see GridComponent::dynInitializeA for more details action. @param[in] inputs the input arguments @param[in] stateDataValue the data representing the current state to operate on - @param[in] sMode the solverMode which is being solved for + @param[in] sMode the SolverMode which is being solved for */ virtual void - preEx(const IOdata& inputs, const stateData& stateDataValue, const solverMode& sMode); + preEx(const IOdata& inputs, const stateData& stateDataValue, const SolverMode& sMode); /****************************************** Functions related to root finding @@ -667,7 +667,7 @@ see GridComponent::dynInitializeA for more details virtual void rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& sMode); + const SolverMode& sMode); /** *a root has occurred now take action @@ -679,7 +679,7 @@ see GridComponent::dynInitializeA for more details virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode); + const SolverMode& sMode); /** *evaluate the root functions and execute trigger from a static state for operation after an @@ -691,7 +691,7 @@ see GridComponent::dynInitializeA for more details **/ virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level); /****************************************** output functions @@ -705,7 +705,7 @@ see GridComponent::dynInitializeA for more details **/ virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const; + const SolverMode& sMode) const; /** *@brief get the time derivative of a single state @@ -717,7 +717,7 @@ see GridComponent::dynInitializeA for more details **/ virtual double getDoutdt(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const; /** @@ -730,7 +730,7 @@ see GridComponent::dynInitializeA for more details **/ virtual double getOutput(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const; /** @@ -753,7 +753,7 @@ see GridComponent::dynInitializeA for more details @param[in] outputNum the number of the state being requested @return the value of the state requested **/ - virtual index_t getOutputLoc(const solverMode& sMode, index_t outputNum = 0) const; + virtual index_t getOutputLoc(const SolverMode& sMode, index_t outputNum = 0) const; /** *@brief get a vector state indices for the output @ details used in cases where the state of one object is used int the computation of another for @@ -762,7 +762,7 @@ see GridComponent::dynInitializeA for more details @return a vector containing all the outputs locations, kNullLocation if there is no state representing the output **/ - virtual IOlocs getOutputLocs(const solverMode& sMode) const; + virtual IOlocs getOutputLocs(const SolverMode& sMode) const; /****************************************** functions for setting and querying defined parameters @@ -794,7 +794,7 @@ see GridComponent::dynInitializeA for more details const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode); + const SolverMode& sMode); /** *@brief compute the partial derivatives of an outputs with respect to a parameter @param[in] param the index code of the parameter to set in an object @@ -809,7 +809,7 @@ see GridComponent::dynInitializeA for more details index_t outputNum, const IOdata& inputs, const stateData& sD, - const solverMode& sMode); + const SolverMode& sMode); /**** other items */ @@ -827,6 +827,6 @@ see GridComponent::dynInitializeA for more details @param comp the object to display the states for @param sMode the mode which to display the states for */ -void printStateNames(const GridComponent* comp, const solverMode& sMode); +void printStateNames(const GridComponent* comp, const SolverMode& sMode); } // namespace griddyn diff --git a/src/griddyn/GridComponentHelperClasses.h b/src/griddyn/GridComponentHelperClasses.h index 819d8cfa3..8bb2d2cf1 100644 --- a/src/griddyn/GridComponentHelperClasses.h +++ b/src/griddyn/GridComponentHelperClasses.h @@ -329,7 +329,7 @@ class solverOffsets { bool jacobianLoaded = false; //!< flag indicated Jacobian size is loaded bool rootsLoaded = false; //!< flag indicated root size is loaded bool offetLoaded = false; //!< flag indicating that offsets have been loaded - solverMode sMode = cLocalSolverMode; //!< the reference solverMode + SolverMode sMode = cLocalSolverMode; //!< the reference SolverMode // local objectSizes stateSizes total; //!< container for total state sizes; diff --git a/src/griddyn/GridDynGovernor.h b/src/griddyn/GridDynGovernor.h index d2ea8969a..3cf5dadfd 100644 --- a/src/griddyn/GridDynGovernor.h +++ b/src/griddyn/GridDynGovernor.h @@ -64,26 +64,26 @@ class Governor: public GridSubModel { virtual void setFlag(std::string_view flag, bool val) override; virtual double get(std::string_view param, gridUnits::units_t unitType = gridUnits::defUnit) const override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + const SolverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; protected: // virtual void setTime(coreTime time){prevTime=time;}; diff --git a/src/griddyn/GridDynSimulation.h b/src/griddyn/GridDynSimulation.h index d8022b65c..01c764021 100644 --- a/src/griddyn/GridDynSimulation.h +++ b/src/griddyn/GridDynSimulation.h @@ -130,11 +130,11 @@ class GridDynSimulation: public GridSimulation { std::bitset<64> controlFlags; //!< storage container for user settable flags // ---------------solution mode------------- - const solverMode* defPowerFlowMode = &cPflowSolverMode; //!< link to the default powerFlow mode - const solverMode* defDAEMode = &cDaeSolverMode; //!< link to the default DAE solver mode - const solverMode* defDynAlgMode = + const SolverMode* defPowerFlowMode = &cPflowSolverMode; //!< link to the default powerFlow mode + const SolverMode* defDAEMode = &cDaeSolverMode; //!< link to the default DAE solver mode + const SolverMode* defDynAlgMode = &cDynAlgSolverMode; //!< link to the default algebraic solver mode - const solverMode* defDynDiffMode = + const SolverMode* defDynDiffMode = &cDynDiffSolverMode; //!< link to the default differential solver mode DynamicSolverMethods defaultDynamicSolverMethod = @@ -166,7 +166,7 @@ class GridDynSimulation: public GridSimulation { std::vector extraStateInformation; //!< a vector of additional state information for solveMode pairings std::vector extraDerivInformation; //!< a vector of additional derivative - //!< Information for solverMode pairings + //!< Information for SolverMode pairings std::vector singleStepObjects; //!< objects which require a state update after time step std::vector slkBusses; //!< vector of slack buses to aid in powerFlow adjust @@ -244,7 +244,7 @@ class GridDynSimulation: public GridSimulation { @param[out] consData the array to place the model constraint data @param[in] sMode the solver mode corresponding to array locations in consData */ - void getConstraints(double consData[], const solverMode& sMode) override; + void getConstraints(double consData[], const SolverMode& sMode) override; /** @brief check if the system has any constraints *@return true if there is constraints false if not @@ -308,18 +308,18 @@ class GridDynSimulation: public GridSimulation { virtual void setFlag(std::string_view flag, bool val = true) override; /** @brief get a vector of the states - @param[in] sMode the solverMode to get the states for + @param[in] sMode the SolverMode to get the states for @return a vector containing the states */ - std::vector getState(const solverMode& sMode = cLocalSolverMode) const; + std::vector getState(const SolverMode& sMode = cLocalSolverMode) const; double getState(index_t offset) const override; /** @brief get a particular state @param[in] offset the offset of the state to grab - @param[in] sMode the solverMode corresponding to the state to grab + @param[in] sMode the SolverMode corresponding to the state to grab @return the value of a particular state */ - double getState(index_t offset, const solverMode& sMode) const; + double getState(index_t offset, const SolverMode& sMode) const; // saving and loading data @@ -338,10 +338,10 @@ class GridDynSimulation: public GridSimulation { int countMpiObjects(bool printInfo = false) const; /** @brief get the number of non-zeros in the most recent Jacobian calculation - @param[in] sMode the solverMode to get the number of non-zeros for + @param[in] sMode the SolverMode to get the number of non-zeros for @return the number of non-zero elements in the Jacobian */ - count_t nonZeros(const solverMode& sMode) const; + count_t nonZeros(const SolverMode& sMode) const; /** @brief compute the network residuals computes a set of function for the power system such $r(\hat{x},\hat{x'})=f(x,x)- @@ -350,40 +350,40 @@ class GridDynSimulation: public GridSimulation { @param[in] state the state information to evaluation @param[in] dstate_dt the time derivative of the state @param[out] resid the storage location for the residual function - @param[in] sMode the solverMode to solve for + @param[in] sMode the SolverMode to solve for @return integer indicating success (0) or failure (non-zero) */ int residualFunction(coreTime time, const double state[], const double dstate_dt[], double resid[], - const solverMode& sMode) noexcept; + const SolverMode& sMode) noexcept; /** @brief compute the derivatives for all differential states @param[in] time the simulation time of the evaluation @param[in] state the state information to evaluation @param[out] dstate_dt the time derivative of the state - @param[in] sMode the solverMode to solve for + @param[in] sMode the SolverMode to solve for @return integer indicating success (0) or failure (non-zero) */ int derivativeFunction(coreTime time, const double state[], double dstate_dt[], - const solverMode& sMode) noexcept; + const SolverMode& sMode) noexcept; /** @brief compute an update to all algebraic states compute $x=f(\hat{x})$ @param[in] time the simulation time of the evaluation @param[in] state the state information to evaluation @param[out] update the updated state information - @param[in] sMode the solverMode to solve for + @param[in] sMode the SolverMode to solve for @param[in] alpha a multiplication factor for updates that are expected to be iterative @return integer indicating success (0) or failure (non-zero) */ int algUpdateFunction(coreTime time, const double state[], double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) noexcept; /** @brief compute the Jacobian of the residuals @@ -393,7 +393,7 @@ class GridDynSimulation: public GridSimulation { @param[in] dstate_dt the time derivative of the state @param[out] matrixDataRef the matrixData object to store the Jacobian information into @param[in] cjValue the constant of integration for use in Jacobian elements using derivatives - @param[in] sMode the solverMode to solve for + @param[in] sMode the SolverMode to solve for @return integer indicating success (0) or failure (non-zero) */ int jacobianFunction(coreTime time, @@ -401,7 +401,7 @@ class GridDynSimulation: public GridSimulation { const double dstate_dt[], matrixData& matrixDataRef, double cjValue, - const solverMode& sMode) noexcept; + const SolverMode& sMode) noexcept; /** @brief compute any root values computes the roots for any root finding functions used in the system @@ -409,14 +409,14 @@ class GridDynSimulation: public GridSimulation { @param[in] state the state information to evaluation @param[in] dstateDt the time derivative of the state @param[out] roots the storage location for the roots - @param[in] sMode the solverMode to solve for + @param[in] sMode the SolverMode to solve for @return integer indicating success (0) or failure (non-zero) */ int rootFindingFunction(coreTime time, const double state[], const double dstate_dt[], double roots[], - const solverMode& sMode) noexcept; + const SolverMode& sMode) noexcept; /** @brief find the derivatives of the residual function with respect to the given parameters @param[in] time the simulation time of the evaluation @@ -425,7 +425,7 @@ class GridDynSimulation: public GridSimulation { @param[in] state the state information to evaluation @param[in] dstate_dt the time derivative of the state @param[out] matrixDataRef the matrixData object to store the partial derivatives - @param[in] sMode the solverMode to use for the computations + @param[in] sMode the SolverMode to use for the computations */ void parameterDerivatives(coreTime time, ParameterSet& parameterOperators, @@ -435,33 +435,33 @@ class GridDynSimulation: public GridSimulation { const double state[], const double dstateDt[], matrixData& matrixDataRef, - const solverMode& sMode); + const SolverMode& sMode); /** @brief solve for the algebraic components of a system for use with the ode solvers @param[in] time the simulation time of the evaluation @param[in] diffState the current derivative information @param[in] deriv the current derivative information -@param[in] sMode the solverMode to solve related to the differential state information +@param[in] sMode the SolverMode to solve related to the differential state information @return integer indicating success (0) or failure (non-zero) */ int dynAlgebraicSolve(coreTime time, const double diffState[], const double deriv[], - const solverMode& sMode) noexcept; + const SolverMode& sMode) noexcept; - // solverMode and SolverInterface search functions + // SolverMode and SolverInterface search functions - /** @brief get the solverMode dependent on a particular index of the solver data structure + /** @brief get the SolverMode dependent on a particular index of the solver data structure @param[in] index the index into the SolverInterface storage array - @return the solverMode named by the string or a blank one if none can be found + @return the SolverMode named by the string or a blank one if none can be found */ - const solverMode& getSolverMode(index_t index) const; + const SolverMode& getSolverMode(index_t index) const; - /** @brief get the solverMode named by a string - @param[in] solverType the name of the SolverInterface to get the solverMode for - @return the solverMode named by the string or a blank one if none can be found + /** @brief get the SolverMode named by a string + @param[in] solverType the name of the SolverInterface to get the SolverMode for + @return the SolverMode named by the string or a blank one if none can be found */ - solverMode getSolverMode(std::string_view solverType); + SolverMode getSolverMode(std::string_view solverType); /** @brief get the SolverInterface referenced by a particular index into the SolverInterface array @@ -481,14 +481,14 @@ class GridDynSimulation: public GridSimulation { @param[in] sMode the solver mode to get the residual information for @return a shared pointer to an SolverInterface object */ - std::shared_ptr getSolverInterface(const solverMode& sMode) const; + std::shared_ptr getSolverInterface(const SolverMode& sMode) const; /** @brief get a shared pointer to a SolverInterface object non-const version that can create new SolverInterface objects if necessary @param[in] sMode the solver mode to get the residual information for @return a shared pointer to an SolverInterface object */ - std::shared_ptr getSolverInterface(const solverMode& sMode); + std::shared_ptr getSolverInterface(const SolverMode& sMode); /** @brief get the SolverInterface referenced by name @param[in] solverName string representing the SolverInterface name, can be customized name or a @@ -524,9 +524,9 @@ class GridDynSimulation: public GridSimulation { /** @brief set the default solver for particular solution types to a specific solver @param[in] mode the solution mode to set the solver For - @param[in] sMode the solverMode corresponding to a particular solver + @param[in] sMode the SolverMode corresponding to a particular solver */ - void setDefaultMode(SolutionModes mode, const solverMode& sMode); + void setDefaultMode(SolutionModes mode, const SolverMode& sMode); /** @brief check if the simulation object has dynamic models basically checks if there are any differential states in the default solution mode @@ -550,12 +550,12 @@ class GridDynSimulation: public GridSimulation { virtual void solverSet(std::string_view solverName, std::string_view field, std::string_view val); - /** @brief get the current solverMode from the simulation - @param[in] sMode input solverMode to check + /** @brief get the current SolverMode from the simulation + @param[in] sMode input SolverMode to check @return if sMode is valid it returns that if not it finds the current active mode and returns a reference to that */ - solverMode getCurrentMode(const solverMode& sMode = cEmptySolverMode) const; + SolverMode getCurrentMode(const SolverMode& sMode = cEmptySolverMode) const; /** @brief makes sure the SolverInterface object is ready to run solutions @param[in] solver pointer to a solver to make ready @@ -563,9 +563,9 @@ class GridDynSimulation: public GridSimulation { void getSolverReady(std::shared_ptr& solver); /** @brief load a stateData object with extra state information if necessary @param[in] stateDataRef the stateData object to load - @param[in] sMode the solverMode of the state Data object + @param[in] sMode the SolverMode of the state Data object */ - void fillExtraStateData(stateData& stateDataRef, const solverMode& sMode) const; + void fillExtraStateData(stateData& stateDataRef, const SolverMode& sMode) const; /** @brief add an initialization function that will execute prior to the internal initialization in HELICS @param fptr a function object that returns an int. if the value is non-zero it returns a @@ -575,37 +575,37 @@ class GridDynSimulation: public GridSimulation { protected: /** @brief makes sure the specified mode has the correct offsets - @param[in] sMode the solverMode of the offsets to check + @param[in] sMode the SolverMode of the offsets to check */ - void checkOffsets(const solverMode& sMode); + void checkOffsets(const SolverMode& sMode); /** @brief get and update a SolverInterface object the difference here is that the object may not exist, in which case it is created and loaded with recent information from the models - @param[in] sMode the solverMode to get the data for + @param[in] sMode the SolverMode to get the data for @return a shared pointer to the SolverInterface object */ - std::shared_ptr updateSolver(const solverMode& sMode); + std::shared_ptr updateSolver(const SolverMode& sMode); - /** @brief get a pointer to a solverMode based on a string - @param[in] solverType the string representing the solverMode, this can be a particular type of - solverMode or the name of a solver - @return the solverMode named by the string or a blank one if none can be found + /** @brief get a pointer to a SolverMode based on a string + @param[in] solverType the string representing the SolverMode, this can be a particular type of + SolverMode or the name of a solver + @return the SolverMode named by the string or a blank one if none can be found */ - const solverMode* getSolverModePtr(std::string_view solverType) const; + const SolverMode* getSolverModePtr(std::string_view solverType) const; - /** @brief get a pointer to a solverMode dependent on a particular index of the solver data + /** @brief get a pointer to a SolverMode dependent on a particular index of the solver data structure @param[in] index the index into the SolverInterface storage array - @return the solverMode named by the string or a blank one if none can be found + @return the SolverMode named by the string or a blank one if none can be found */ - const solverMode* getSolverModePtr(index_t index) const; + const SolverMode* getSolverModePtr(index_t index) const; /** @brief reinitialize the power flow solver @param[in] sMode the solver Mode to reinitialize @param[in] change the adjustment mode */ - void reInitpFlow(const solverMode& sMode, ChangeCode change = ChangeCode::NO_CHANGE); + void reInitpFlow(const SolverMode& sMode, ChangeCode change = ChangeCode::NO_CHANGE); /** @brief perform a global generator adjustment operation @param[in] adjustment the amount of power to distribute to the allowed generators @@ -623,26 +623,26 @@ class GridDynSimulation: public GridSimulation { /** @brief update the offsets associated with a particular mode @param[in] sMode the solver Mode to update the offsets for */ - virtual void updateOffsets(const solverMode& sMode); + virtual void updateOffsets(const SolverMode& sMode); /** @brief make the simulator ready to perform a particular simulation @param[in] desiredState the desired state - @param[in] sMode the solverMode to make the operations in + @param[in] sMode the SolverMode to make the operations in @return FUNCTION_EXECUTION_SUCCESS(0) if successful negative number if not */ - int makeReady(GridState desiredState, const solverMode& sMode); + int makeReady(GridState desiredState, const SolverMode& sMode); /** @brief set the maximum number of non-zeros in the Jacobian @param[in] sMode the solver mode to set the max number of non-zeros in the Jacobian @param[in] nonZeros the size to set */ - void setMaxNonZeros(const solverMode& sMode, count_t nonZeros); + void setMaxNonZeros(const SolverMode& sMode, count_t nonZeros); /** @brief reinitialize the dynamic simulation @param[in] sMode the solver mode to reinitialize @return FUNCTION_EXECUTION_SUCCESS(0) if successful negative number if not */ - int reInitDyn(const solverMode& sMode); + int reInitDyn(const SolverMode& sMode); /** @brief execute a DAE simulation until the given stop time @param[in] tStop the stop time for the simulation @@ -669,21 +669,21 @@ class GridDynSimulation: public GridSimulation { @param[in] sMode the solver mode for which to generate the initial conditions @return FUNCTION_EXECUTION_SUCCESS(0) if successful negative number if not */ - int generateDaeDynamicInitialConditions(const solverMode& sMode); + int generateDaeDynamicInitialConditions(const SolverMode& sMode); /** @brief generate a convergent partitioned solution @param[in] sModeAlg the solver mode of the algebraic solver @param[in] sModeDiff the solver mode of the differential solver @return FUNCTION_EXECUTION_SUCCESS(0) if successful negative number if not */ - int generatePartitionedDynamicInitialConditions(const solverMode& sModeAlg, - const solverMode& sModeDiff); + int generatePartitionedDynamicInitialConditions(const SolverMode& sModeAlg, + const SolverMode& sModeDiff); /** @brief load the offset codes for the objects - @param[in] sMode the solvermode to setup the offsets for + @param[in] sMode the SolverMode to setup the offsets for @param[in] offsetOrdering the type of ordering to use */ - virtual void setupOffsets(const solverMode& sMode, OffsetOrdering offsetOrdering); + virtual void setupOffsets(const SolverMode& sMode, OffsetOrdering offsetOrdering); /** @brief function to help with IDA solving steps @param[in] retval the return code from the solver @@ -698,35 +698,35 @@ class GridDynSimulation: public GridSimulation { function checks for various conditions that cause specific things in the solver or simulation to be reset the nature of the reset can be driven by the reset_code given as an argument or internal flags from alerts or other mechanisms - @param[in] sMode the solverMode to operate on + @param[in] sMode the SolverMode to operate on @param[in] change the optional change code that the reset should function to, otherwise automatically detected @return true if the check did something, false if nothing has changed */ - bool dynamicCheckAndReset(const solverMode& sMode, ChangeCode change = ChangeCode::NO_CHANGE); + bool dynamicCheckAndReset(const SolverMode& sMode, ChangeCode change = ChangeCode::NO_CHANGE); - int handleStateChange(const solverMode& sMode); - void handleRootChange(const solverMode& sMode, std::shared_ptr& dynData); + int handleStateChange(const SolverMode& sMode); + void handleRootChange(const SolverMode& sMode, std::shared_ptr& dynData); int checkAlgebraicRoots(std::shared_ptr& dynData); /** @brief checks events for events needing to run and runs them then checks if a reset is needed if so it does so @param[in] cTime the time to run the events - @param[in] sMode the solverMode to run + @param[in] sMode the SolverMode to run @return true if the reset Function was run and did something */ - bool checkEventsForDynamicReset(coreTime cTime, const solverMode& sMode); + bool checkEventsForDynamicReset(coreTime cTime, const SolverMode& sMode); private: void setupDynamicDAE(); void setupDynamicPartitioned(); int dynamicDAEStartupConditions(std::shared_ptr& dynData, - const solverMode& sMode); + const SolverMode& sMode); int dynamicPartitionedStartupConditions(std::shared_ptr& dynDataDiff, std::shared_ptr& dynDataAlg, - const solverMode& sModeDiff, - const solverMode& sModeAlg); + const SolverMode& sModeDiff, + const SolverMode& sModeAlg); int runDynamicSolverStep(std::shared_ptr& dynData, coreTime nextStop, coreTime& timeActual); diff --git a/src/griddyn/GridPrimary.cpp b/src/griddyn/GridPrimary.cpp index 5f5f3c4f9..c16a5fe07 100644 --- a/src/griddyn/GridPrimary.cpp +++ b/src/griddyn/GridPrimary.cpp @@ -73,7 +73,7 @@ double gridPrimary::get(std::string_view param, units::unit unitType) const void gridPrimary::converge(coreTime /*time*/, double /*state*/[], double /*dstate_dt*/[], - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, ConvergeMode /*mode*/, double /*tol*/) { @@ -82,7 +82,7 @@ void gridPrimary::converge(coreTime /*time*/, void gridPrimary::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { GridComponent::setState(time, state, dstate_dt, sMode); // update local computations @@ -92,7 +92,7 @@ void gridPrimary::setState(coreTime time, void gridPrimary::delayedResidual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { residual(inputs, stateDataValue, resid, sMode); } @@ -100,7 +100,7 @@ void gridPrimary::delayedResidual(const IOdata& inputs, void gridPrimary::delayedDerivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { derivative(inputs, stateDataValue, deriv, sMode); } @@ -108,7 +108,7 @@ void gridPrimary::delayedDerivative(const IOdata& inputs, void gridPrimary::delayedAlgebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { algebraicUpdate(inputs, stateDataValue, update, sMode, alpha); @@ -118,7 +118,7 @@ void gridPrimary::delayedJacobian(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { jacobianElements(inputs, stateDataValue, matrixDataValue, inputLocs, sMode); } diff --git a/src/griddyn/GridPrimary.h b/src/griddyn/GridPrimary.h index 456f85282..389ccdb25 100644 --- a/src/griddyn/GridPrimary.h +++ b/src/griddyn/GridPrimary.h @@ -71,52 +71,52 @@ class gridPrimary: public GridComponent { virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; /** @brief get the residual computation for object requiring a delay basically calls the residual calculation on the delayed objects @param[in] stateDataValue the data representing the current state to operate on @param[out] resid the array to store the computed derivative values - @param[in] sMode the solverMode which is being solved for + @param[in] sMode the SolverMode which is being solved for */ virtual void delayedResidual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode); + const SolverMode& sMode); /** @brief get the residual computation for object requiring a delay basically calls the derivative calculation on the delayed objects @param[in] stateDataValue the data representing the current state to operate on @param[out] deriv the array to store the computed derivative values - @param[in] sMode the solverMode which is being solved for + @param[in] sMode the SolverMode which is being solved for */ virtual void delayedDerivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode); + const SolverMode& sMode); /** @brief get the algebraic update for object requesting a delay basically calls the residual calculation on the delayed objects @param[in] stateDataValue the data representing the current state to operate on @param[out] update the array to store the computed derivative values - @param[in] sMode the solverMode which is being solved for + @param[in] sMode the SolverMode which is being solved for */ virtual void delayedAlgebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha); /** @brief get the residual computation for object requiring a delay basically calls the Jacobian calculation on the delayed objects @param[in] stateDataValue the data representing the current state to operate on @param[out] matrixDataValue the matrixData structure to store the Jacobian values - @param[in] sMode the solverMode which is being solved for + @param[in] sMode the SolverMode which is being solved for */ virtual void delayedJacobian(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode); + const SolverMode& sMode); /** @brief try to shift the states to something more consistent called when the current states do not make a consistent condition, calling converge will @@ -126,14 +126,14 @@ class gridPrimary: public GridComponent { @param[in] time the time of the corresponding states @param[in,out] state the states of the system at present and shifted to match the updates @param[in,out] dstate_dt the derivatives of the state that get updated - @param[in] sMode the solverMode matching the states + @param[in] sMode the SolverMode matching the states @param[in] mode the mode of the convergence @param[in] tol the convergence tolerance */ virtual void converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode mode = ConvergeMode::high_error_only, double tol = 0.01); diff --git a/src/griddyn/GridSecondary.cpp b/src/griddyn/GridSecondary.cpp index a6570f770..dacf0cb87 100644 --- a/src/griddyn/GridSecondary.cpp +++ b/src/griddyn/GridSecondary.cpp @@ -140,14 +140,14 @@ void gridSecondary::set(std::string_view param, double val, units::unit unitType double gridSecondary::getRealPower(const IOdata& /*inputs*/, const stateData& /*stateDataValue*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return 0.0; } double gridSecondary::getReactivePower(const IOdata& /*inputs*/, const stateData& /*stateDataValue*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return 0.0; } @@ -170,7 +170,7 @@ double gridSecondary::getAdjustableCapacityDown(coreTime /*time*/) const } double gridSecondary::getDoutdt(const IOdata& /*inputs*/, const stateData& /*stateDataValue*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t /*outputNum*/) const { return 0.0; @@ -178,7 +178,7 @@ double gridSecondary::getDoutdt(const IOdata& /*inputs*/, double gridSecondary::getOutput(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum) const { if (outputNum == PoutLocation) { @@ -203,7 +203,7 @@ double gridSecondary::getOutput(index_t outputNum) const IOdata gridSecondary::getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { IOdata out(2); out[PoutLocation] = getRealPower(inputs, stateDataValue, sMode); @@ -214,7 +214,7 @@ IOdata gridSecondary::getOutputs(const IOdata& inputs, IOdata gridSecondary::predictOutputs(coreTime /*predictionTime*/, const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { IOdata out(2); out[PoutLocation] = getRealPower(inputs, stateDataValue, sMode); diff --git a/src/griddyn/GridSecondary.h b/src/griddyn/GridSecondary.h index 0bcac9098..330ffd571 100644 --- a/src/griddyn/GridSecondary.h +++ b/src/griddyn/GridSecondary.h @@ -59,7 +59,7 @@ class gridSecondary: public GridComponent { **/ virtual double getRealPower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const; + const SolverMode& sMode) const; /** *@brief get the reactive output power @@ -70,7 +70,7 @@ class gridSecondary: public GridComponent { **/ virtual double getReactivePower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const; + const SolverMode& sMode) const; /** *@brief get the real output power from local data @@ -93,7 +93,7 @@ class gridSecondary: public GridComponent { **/ virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; const GridBus* getBus() const { return bus; } @@ -107,7 +107,7 @@ class gridSecondary: public GridComponent { **/ virtual double getDoutdt(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t num = 0) const override; /** @@ -120,7 +120,7 @@ class gridSecondary: public GridComponent { **/ virtual double getOutput(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const override; /** @@ -141,7 +141,7 @@ class gridSecondary: public GridComponent { virtual IOdata predictOutputs(coreTime predictionTime, const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const; + const SolverMode& sMode) const; /** *@brief get the available upwards generating capacity of a system diff --git a/src/griddyn/Link.h b/src/griddyn/Link.h index a2f072f12..adc725259 100644 --- a/src/griddyn/Link.h +++ b/src/griddyn/Link.h @@ -115,7 +115,7 @@ class Link: public gridPrimary { virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) override; + const SolverMode& sMode) override; /** @brief allow the real power flow to be fixed by adjusting the properties of one bus or another performs the calculations necessary to get the power at the measureTerminal to be a @@ -169,7 +169,7 @@ class Link: public gridPrimary { */ virtual void pFlowCheck(std::vector& Violation_vector) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; /** @brief do a quick update (may be deprecated) * @return the power transfer */ @@ -184,10 +184,10 @@ class Link: public gridPrimary { virtual double getAngle() const; /** @brief get angle differential of the buses @param[in] state the state of the system - @param[in] sMode the solverMode the state is based on + @param[in] sMode the SolverMode the state is based on * @return the angle difference */ - virtual double getAngle(const double state[], const solverMode& sMode) const; + virtual double getAngle(const double state[], const SolverMode& sMode) const; /** @brief get the absolute angle of an attached bus @param[in] busId either 1 or 2 to get the actual angle of the bus if the busID is used it gets the opposite angle @@ -201,7 +201,7 @@ class Link: public gridPrimary { */ double - getBusAngle(const stateData& stateData, const solverMode& sMode, id_type_t busId = 0) const; + getBusAngle(const stateData& stateData, const SolverMode& sMode, id_type_t busId = 0) const; /** @brief get the voltage of an attached bus @param[in] busId either 1 or 2 or the object id of the bus * @return the voltage @@ -268,7 +268,7 @@ class Link: public gridPrimary { */ virtual count_t terminalCount() const { return 2; } - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; /** @brief get the max transfer capacity * @return the max capacity */ @@ -306,22 +306,22 @@ class Link: public gridPrimary { const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode); + const SolverMode& sMode); using GridComponent::outputPartialDerivatives; virtual void outputPartialDerivatives(id_type_t busId, const stateData& sD, matrixData& md, - const solverMode& sMode); + const SolverMode& sMode); virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) const override; - virtual IOdata getOutputs(id_type_t busId, const stateData& sD, const solverMode& sMode) const; + const SolverMode& sMode) const override; + virtual IOdata getOutputs(id_type_t busId, const stateData& sD, const SolverMode& sMode) const; virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; protected: /** @brief deal with any effects of a switch change diff --git a/src/griddyn/Load.h b/src/griddyn/Load.h index 01a51be86..190f93c71 100644 --- a/src/griddyn/Load.h +++ b/src/griddyn/Load.h @@ -61,10 +61,10 @@ class GridLoad: public gridSecondary { virtual double getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; /** get the real output power that based on the given voltage @param[in] V the bus voltage @return the real power consumed by the load*/ @@ -76,7 +76,7 @@ class GridLoad: public gridSecondary { virtual double getRealPower() const override; virtual double getReactivePower() const override; // for saving the state - count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; protected: // little helper functions to do some calculations diff --git a/src/griddyn/NumericEstimationFunctions.cpp b/src/griddyn/NumericEstimationFunctions.cpp index 544e06de6..f7187c52d 100644 --- a/src/griddyn/NumericEstimationFunctions.cpp +++ b/src/griddyn/NumericEstimationFunctions.cpp @@ -17,7 +17,7 @@ void numericJacobianCalculation(GridComponent* /* comp */, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { std::vector test; [[maybe_unused]] std::vector testState; @@ -37,7 +37,7 @@ void numericJacobianCalculation(GridComponent* /* comp */, void copyObjectLocalState(GridComponent* comp, const double state[], double newState[], - const solverMode& sMode) + const SolverMode& sMode) { auto sts = getObjectLocalStateIndices(comp, sMode); for (auto st : sts) { @@ -45,7 +45,7 @@ void copyObjectLocalState(GridComponent* comp, } } -std::vector getObjectLocalStateIndices(const GridComponent* comp, const solverMode& sMode) +std::vector getObjectLocalStateIndices(const GridComponent* comp, const SolverMode& sMode) { std::vector states; const auto& offsets = comp->getOffsets(sMode); diff --git a/src/griddyn/NumericEstimationFunctions.h b/src/griddyn/NumericEstimationFunctions.h index 433dcfc96..4da0e48ef 100644 --- a/src/griddyn/NumericEstimationFunctions.h +++ b/src/griddyn/NumericEstimationFunctions.h @@ -15,7 +15,7 @@ class matrixData; namespace griddyn { class GridComponent; class stateData; -class solverMode; +class SolverMode; /** *@brief numerically compute the partial derivatives of the internal states with respect to inputs @@ -35,7 +35,7 @@ void numericJacobianCalculation(GridComponent* comp, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode); + const SolverMode& sMode); /** @brief function to copy the local state of an object from one data to another @@ -47,13 +47,13 @@ void numericJacobianCalculation(GridComponent* comp, void copyObjectLocalState(const GridComponent* comp, const double state[], double newstate[], - const solverMode& sMode); + const SolverMode& sMode); /** @brief get a vector of all the local state locations of an object @param[in] comp the object get all the state locations @param[in] sMode the solver mode to get the locations for @return a vector containing the indices of the states */ -std::vector getObjectLocalStateIndices(const GridComponent* comp, const solverMode& sMode); +std::vector getObjectLocalStateIndices(const GridComponent* comp, const SolverMode& sMode); } // namespace griddyn diff --git a/src/griddyn/OffsetTable.cpp b/src/griddyn/OffsetTable.cpp index a740c2bf1..b784dbd9f 100644 --- a/src/griddyn/OffsetTable.cpp +++ b/src/griddyn/OffsetTable.cpp @@ -22,7 +22,7 @@ OffsetTable::OffsetTable(): offsetContainer(DEFAULT_OFFSET_CONTAINER_SIZE) offsetContainer[0].sMode = cLocalSolverMode; } -bool OffsetTable::isLoaded(const solverMode& sMode) const +bool OffsetTable::isLoaded(const SolverMode& sMode) const { return (isValidIndex(sMode.offsetIndex)) && ((offsetContainer[sMode.offsetIndex].stateLoaded) && @@ -30,22 +30,22 @@ bool OffsetTable::isLoaded(const solverMode& sMode) const (offsetContainer[sMode.offsetIndex].jacobianLoaded)); } -bool OffsetTable::isStateCountLoaded(const solverMode& sMode) const +bool OffsetTable::isStateCountLoaded(const SolverMode& sMode) const { return isValidIndex(sMode.offsetIndex) && offsetContainer[sMode.offsetIndex].stateLoaded; } -bool OffsetTable::isRootCountLoaded(const solverMode& sMode) const +bool OffsetTable::isRootCountLoaded(const SolverMode& sMode) const { return isValidIndex(sMode.offsetIndex) && offsetContainer[sMode.offsetIndex].rootsLoaded; } -bool OffsetTable::isJacobianCountLoaded(const solverMode& sMode) const +bool OffsetTable::isJacobianCountLoaded(const SolverMode& sMode) const { return isValidIndex(sMode.offsetIndex) && offsetContainer[sMode.offsetIndex].jacobianLoaded; } -solverOffsets& OffsetTable::getOffsets(const solverMode& sMode) +solverOffsets& OffsetTable::getOffsets(const SolverMode& sMode) { if (!isValidIndex(sMode.offsetIndex)) { offsetContainer.resize(sMode.offsetIndex + 1); @@ -54,12 +54,12 @@ solverOffsets& OffsetTable::getOffsets(const solverMode& sMode) return offsetContainer[sMode.offsetIndex]; } -const solverOffsets& OffsetTable::getOffsets(const solverMode& sMode) const +const solverOffsets& OffsetTable::getOffsets(const SolverMode& sMode) const { return isValidIndex(sMode.offsetIndex) ? offsetContainer[sMode.offsetIndex] : NULL_OFFSETS; } -void OffsetTable::setOffsets(const solverOffsets& newOffsets, const solverMode& sMode) +void OffsetTable::setOffsets(const solverOffsets& newOffsets, const SolverMode& sMode) { if (!isValidIndex(sMode.offsetIndex)) { offsetContainer.resize(sMode.offsetIndex + 1); @@ -68,7 +68,7 @@ void OffsetTable::setOffsets(const solverOffsets& newOffsets, const solverMode& offsetContainer[sMode.offsetIndex].setOffsets(newOffsets); } -void OffsetTable::setOffset(index_t newOffset, const solverMode& sMode) +void OffsetTable::setOffset(index_t newOffset, const SolverMode& sMode) { if (!isValidIndex(sMode.offsetIndex)) { offsetContainer.resize(sMode.offsetIndex + 1); @@ -77,7 +77,7 @@ void OffsetTable::setOffset(index_t newOffset, const solverMode& sMode) offsetContainer[sMode.offsetIndex].setOffset(newOffset); } -void OffsetTable::setAlgOffset(index_t newOffset, const solverMode& sMode) +void OffsetTable::setAlgOffset(index_t newOffset, const SolverMode& sMode) { if (!isValidIndex(sMode.offsetIndex)) { offsetContainer.resize(sMode.offsetIndex + 1); @@ -86,7 +86,7 @@ void OffsetTable::setAlgOffset(index_t newOffset, const solverMode& sMode) offsetContainer[sMode.offsetIndex].algOffset = newOffset; } -void OffsetTable::setDiffOffset(index_t newOffset, const solverMode& sMode) +void OffsetTable::setDiffOffset(index_t newOffset, const SolverMode& sMode) { if (!isValidIndex(sMode.offsetIndex)) { offsetContainer.resize(sMode.offsetIndex + 1); @@ -95,7 +95,7 @@ void OffsetTable::setDiffOffset(index_t newOffset, const solverMode& sMode) offsetContainer[sMode.offsetIndex].diffOffset = newOffset; } -void OffsetTable::setVOffset(index_t newOffset, const solverMode& sMode) +void OffsetTable::setVOffset(index_t newOffset, const SolverMode& sMode) { if (!isValidIndex(sMode.offsetIndex)) { offsetContainer.resize(sMode.offsetIndex + 1); @@ -104,7 +104,7 @@ void OffsetTable::setVOffset(index_t newOffset, const solverMode& sMode) offsetContainer[sMode.offsetIndex].vOffset = newOffset; } -void OffsetTable::setAOffset(index_t newOffset, const solverMode& sMode) +void OffsetTable::setAOffset(index_t newOffset, const SolverMode& sMode) { if (!isValidIndex(sMode.offsetIndex)) { offsetContainer.resize(sMode.offsetIndex + 1); @@ -113,7 +113,7 @@ void OffsetTable::setAOffset(index_t newOffset, const solverMode& sMode) offsetContainer[sMode.offsetIndex].aOffset = newOffset; } -void OffsetTable::setRootOffset(index_t newOffset, const solverMode& sMode) +void OffsetTable::setRootOffset(index_t newOffset, const SolverMode& sMode) { if (!isValidIndex(sMode.offsetIndex)) { offsetContainer.resize(sMode.offsetIndex + 1); @@ -122,7 +122,7 @@ void OffsetTable::setRootOffset(index_t newOffset, const solverMode& sMode) offsetContainer[sMode.offsetIndex].rootOffset = newOffset; } -index_t OffsetTable::maxIndex(const solverMode& sMode) const +index_t OffsetTable::maxIndex(const SolverMode& sMode) const { if (!isValidIndex(sMode.offsetIndex)) { return 0; @@ -153,7 +153,7 @@ index_t OffsetTable::maxIndex(const solverMode& sMode) const return maxUsedIndex; } -void OffsetTable::getLocations(const solverMode& sMode, Lp* loc) const +void OffsetTable::getLocations(const SolverMode& sMode, Lp* loc) const { loc->algOffset = offsetContainer[sMode.offsetIndex].algOffset; loc->diffOffset = offsetContainer[sMode.offsetIndex].diffOffset; @@ -251,12 +251,12 @@ void OffsetTable::localUpdateAll(bool dynamicOnly) } } } -const solverMode& OffsetTable::getSolverMode(index_t index) const +const SolverMode& OffsetTable::getSolverMode(index_t index) const { return isValidIndex(index) ? offsetContainer[index].sMode : cEmptySolverMode; } -const solverMode& OffsetTable::find(const solverMode& tMode) const +const SolverMode& OffsetTable::find(const SolverMode& tMode) const { for (const auto& offsetInfo : offsetContainer) { if (offsetInfo.sMode.dynamic != tMode.dynamic) { @@ -285,7 +285,7 @@ const solverMode& OffsetTable::find(const solverMode& tMode) const Lp OffsetTable::getLocations(const stateData& stateDataValue, double dest[], - const solverMode& sMode, + const SolverMode& sMode, const GridComponent* comp) const { Lp loc = getLocations(stateDataValue, sMode, comp); @@ -310,7 +310,7 @@ Lp OffsetTable::getLocations(const stateData& stateDataValue, } Lp OffsetTable::getLocations(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, const GridComponent* comp) const { Lp loc; diff --git a/src/griddyn/OffsetTable.h b/src/griddyn/OffsetTable.h index c6419cc61..a9d7be100 100644 --- a/src/griddyn/OffsetTable.h +++ b/src/griddyn/OffsetTable.h @@ -12,7 +12,7 @@ namespace griddyn { /** - * @brief Helper class encapsulating offsets for the various solution solverMode types + * @brief Helper class encapsulating offsets for the various solution SolverMode types **/ class OffsetTable { private: @@ -27,36 +27,36 @@ class OffsetTable { OffsetTable(); /** @brief check whether an offset set has been fully loaded - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return a flag (true) if loaded (false) if not */ - bool isLoaded(const solverMode& sMode) const; + bool isLoaded(const SolverMode& sMode) const; /** @brief check whether the state information is loaded - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return a flag (true) if loaded (false) if not */ - bool isStateCountLoaded(const solverMode& sMode) const; + bool isStateCountLoaded(const SolverMode& sMode) const; /** @brief check whether the root information is loaded - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return a flag (true) if loaded (false) if not */ - bool isRootCountLoaded(const solverMode& sMode) const; + bool isRootCountLoaded(const SolverMode& sMode) const; /** @brief check whether the Jacobian information is loaded - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return a flag (true) if loaded (false) if not */ - bool isJacobianCountLoaded(const solverMode& sMode) const; - /** @brief set the offsets for a solverMode - *@param[in] sMode the solverMode we are interested in + bool isJacobianCountLoaded(const SolverMode& sMode) const; + /** @brief set the offsets for a SolverMode + *@param[in] sMode the SolverMode we are interested in *@param[in] newOffsets the offsets to assign */ - void setOffsets(const solverOffsets& newOffsets, const solverMode& sMode); + void setOffsets(const solverOffsets& newOffsets, const SolverMode& sMode); /** @brief set the base offset *@param[in] newOffset the location to set the offset to - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in */ - void setOffset(index_t newOffset, const solverMode& sMode); + void setOffset(index_t newOffset, const SolverMode& sMode); /**get a pointer the offsets for the local mode */ @@ -70,91 +70,91 @@ class OffsetTable { { return offsetContainer.front(); } - /** @brief get the offsets for a solverMode - *@param[in] sMode the solverMode we are interested in + /** @brief get the offsets for a SolverMode + *@param[in] sMode the SolverMode we are interested in *@return a pointer to a solverOffsets object */ - solverOffsets& getOffsets(const solverMode& sMode); + solverOffsets& getOffsets(const SolverMode& sMode); - /** @brief get the offsets for a solverMode - *@param[in] sMode the solverMode we are interested in + /** @brief get the offsets for a SolverMode + *@param[in] sMode the SolverMode we are interested in *@return a const pointer to a solverOffsets object */ - const solverOffsets& getOffsets(const solverMode& sMode) const; + const solverOffsets& getOffsets(const SolverMode& sMode) const; /** @brief set the base offset of algebraic variables *@param[in] newOffset the location to set the offset to - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in */ - void setAlgOffset(index_t newOffset, const solverMode& sMode); + void setAlgOffset(index_t newOffset, const SolverMode& sMode); /** @brief set the root offset *@param[in] newOffset the location to set the offset to - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in */ - void setRootOffset(index_t newOffset, const solverMode& sMode); + void setRootOffset(index_t newOffset, const SolverMode& sMode); /** @brief set the differential offset *@param[in] newOffset the location to set the offset to - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in */ - void setDiffOffset(index_t newOffset, const solverMode& sMode); + void setDiffOffset(index_t newOffset, const SolverMode& sMode); /** @brief set the voltage offset *@param[in] newOffset the location to set the offset to - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in */ - void setVOffset(index_t newOffset, const solverMode& sMode); + void setVOffset(index_t newOffset, const SolverMode& sMode); /** @brief set the angle offset *@param[in] newOffset the location to set the offset to - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in */ - void setAOffset(index_t newOffset, const solverMode& sMode); + void setAOffset(index_t newOffset, const SolverMode& sMode); /** @brief get the base offset - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return the base offset */ - index_t getAlgOffset(const solverMode& sMode) const + index_t getAlgOffset(const SolverMode& sMode) const { return offsetContainer[sMode.offsetIndex].algOffset; } /** @brief get the differential state offset - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return the differential offset */ - index_t getDiffOffset(const solverMode& sMode) const + index_t getDiffOffset(const SolverMode& sMode) const { return offsetContainer[sMode.offsetIndex].diffOffset; } /**@brief get the root offset - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return the root offset */ - index_t getRootOffset(const solverMode& sMode) const + index_t getRootOffset(const SolverMode& sMode) const { // assert (offsetContainer[static_cast (sMode)].rootOffset != kNullLocation); return offsetContainer[sMode.offsetIndex].rootOffset; } /**@brief get the voltage offset - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return the voltage offset */ - index_t getVOffset(const solverMode& sMode) const + index_t getVOffset(const SolverMode& sMode) const { return offsetContainer[sMode.offsetIndex].vOffset; } /**@brief get the angle offset - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return the angle offset */ - index_t getAOffset(const solverMode& sMode) const + index_t getAOffset(const SolverMode& sMode) const { return offsetContainer[sMode.offsetIndex].aOffset; } /** @brief get the maximum used index - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@return the the maximum used index */ - index_t maxIndex(const solverMode& sMode) const; + index_t maxIndex(const SolverMode& sMode) const; /** @brief get the locations for the data from a stateData pointer and output array - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@param[in] sD the stateData object to fill the Lp from *@param[in] dest the destination location for the calculations @param[in] comp the object to use if local information is required @@ -162,24 +162,24 @@ class OffsetTable { */ Lp getLocations(const stateData& stateDataValue, double dest[], - const solverMode& sMode, + const SolverMode& sMode, const GridComponent* comp) const; /** @brief get the locations for the data from a stateData pointer - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in *@param[in] sD the stateData object to fill the Lp from @param[in] comp the object to use if local information is required @return Lp the Location pointer object to fill */ Lp getLocations(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, const GridComponent* comp) const; /** @brief get the locations offsets for the data - *@param[in] sMode the solverMode we are interested in + *@param[in] sMode the SolverMode we are interested in @param[in] Loc the location pointer to store the data */ - void getLocations(const solverMode& sMode, Lp* Loc) const; + void getLocations(const SolverMode& sMode, Lp* Loc) const; /** @brief unload all the solverOffset objects *@param[in] dynamic_only only unload the dynamic solverObjects */ @@ -204,14 +204,14 @@ class OffsetTable { *@return the size */ count_t size() const { return static_cast(offsetContainer.size()); } - /** @brief get the solverMode corresponding to an index - *@return a solverMode object + /** @brief get the SolverMode corresponding to an index + *@return a SolverMode object */ - const solverMode& getSolverMode(index_t index) const; - /** @brief find a solverMode matching another Mode in everything but index - *@return a solverMode object + const SolverMode& getSolverMode(index_t index) const; + /** @brief find a SolverMode matching another Mode in everything but index + *@return a SolverMode object */ - const solverMode& find(const solverMode& tMode) const; + const SolverMode& find(const SolverMode& tMode) const; private: bool isValidIndex(index_t index) const diff --git a/src/griddyn/Relay.h b/src/griddyn/Relay.h index 95458d072..ccb19f350 100644 --- a/src/griddyn/Relay.h +++ b/src/griddyn/Relay.h @@ -195,7 +195,7 @@ class Relay: public gridPrimary, ObjectOperatorInterface { */ double getConditionValue(index_t conditionNumber, const stateData& sD, - const solverMode& sMode) const; + const SolverMode& sMode) const; /** check if a particular condition is true @param[in] conditionNumber the index of the condition to check @return true if the condition is activated @@ -260,14 +260,14 @@ class Relay: public gridPrimary, ObjectOperatorInterface { virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; /** message processing function for use with communicators @param[in] sourceID the source of the comm message diff --git a/src/griddyn/Source.h b/src/griddyn/Source.h index a61f8820b..7b5d9d240 100644 --- a/src/griddyn/Source.h +++ b/src/griddyn/Source.h @@ -32,31 +32,31 @@ class Source: public GridSubModel { virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t num = 0) const override; virtual double getOutput(index_t outputNum = 0) const override; - virtual index_t getOutputLoc(const solverMode& sMode, index_t num = 0) const override; + virtual index_t getOutputLoc(const SolverMode& sMode, index_t num = 0) const override; virtual units::unit outputUnits(index_t outputNum) const override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; /** update the output to correspond to a new time value*/ virtual void updateOutput(coreTime time); virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; /** update the source output and advance the model time @param[in] time the time to update to diff --git a/src/griddyn/Stabilizer.h b/src/griddyn/Stabilizer.h index 3a511e7f6..e86837001 100644 --- a/src/griddyn/Stabilizer.h +++ b/src/griddyn/Stabilizer.h @@ -36,19 +36,19 @@ class Stabilizer: public GridSubModel { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; }; } // namespace griddyn diff --git a/src/griddyn/blocks/Block.cpp b/src/griddyn/blocks/Block.cpp index 853f885de..3eb2bb436 100644 --- a/src/griddyn/blocks/Block.cpp +++ b/src/griddyn/blocks/Block.cpp @@ -267,7 +267,7 @@ void GridBlock::dynObjectInitializeB(const IOdata& inputs, } } -void GridBlock::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void GridBlock::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { step(time, inputs[0]); } @@ -321,7 +321,7 @@ double GridBlock::step(coreTime time, double input) } double GridBlock::getBlockOutput(const stateData& stateDataValue, - const solverMode& solverModeValue) const + const SolverMode& solverModeValue) const { auto locations = offsets.getLocations(stateDataValue, solverModeValue, this); return opFlags[differential_output] ? *locations.diffStateLoc : *locations.algStateLoc; @@ -335,7 +335,7 @@ double GridBlock::getBlockOutput() const } double GridBlock::getBlockDoutDt(const stateData& stateDataValue, - const solverMode& solverModeValue) const + const SolverMode& solverModeValue) const { if (opFlags[differential_output]) { auto locations = offsets.getLocations(stateDataValue, solverModeValue, this); @@ -358,7 +358,7 @@ void GridBlock::blockResidual(double input, double didt, const stateData& stateDataValue, double resid[], - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { auto& solverOffsetsValue = offsets.getOffsets(solverModeValue); if (solverOffsetsValue.total.diffSize > 0) { @@ -389,7 +389,7 @@ void GridBlock::limiterResidElements(double input, double didt, const stateData& stateDataValue, double resid[], - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { if (opFlags[differential_output]) { auto offset = offsets.getDiffOffset(solverModeValue) + limiter_diff; @@ -436,7 +436,7 @@ void GridBlock::limiterResidElements(double input, void GridBlock::residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { blockResidual(inputs[0], getRateInput(inputs), stateDataValue, resid, solverModeValue); } @@ -472,7 +472,7 @@ double GridBlock::getTestRate(double didt, double currentStateRate) const void GridBlock::blockAlgebraicUpdate(double input, const stateData& stateDataValue, double update[], - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { if (opFlags[differential_output]) { return; @@ -494,7 +494,7 @@ void GridBlock::blockAlgebraicUpdate(double input, void GridBlock::algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& solverModeValue, + const SolverMode& solverModeValue, double /*alpha*/) { blockAlgebraicUpdate(inputs[0], stateDataValue, update, solverModeValue); @@ -504,7 +504,7 @@ void GridBlock::blockDerivative(double /*input*/, double didt, const stateData& stateDataValue, double deriv[], - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { if (opFlags[differential_output]) { auto offset = offsets.getDiffOffset(solverModeValue) + limiter_diff; @@ -528,7 +528,7 @@ void GridBlock::blockDerivative(double /*input*/, void GridBlock::derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { blockDerivative(inputs[0], getRateInput(inputs), stateDataValue, deriv, solverModeValue); } @@ -538,7 +538,7 @@ void GridBlock::blockJacobianElements(double /*input*/, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { if ((opFlags[differential_output]) && (hasDifferential(solverModeValue))) { auto offset = offsets.getDiffOffset(solverModeValue) + limiter_diff; @@ -599,7 +599,7 @@ void GridBlock::jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { blockJacobianElements(inputs[0], getRateInput(inputs), @@ -611,7 +611,7 @@ void GridBlock::jacobianElements(const IOdata& inputs, double GridBlock::getLimiterTestValue(double input, const stateData& stateDataValue, - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { auto offset = (opFlags[differential_output]) ? offsets.getDiffOffset(solverModeValue) : offsets.getAlgOffset(solverModeValue); @@ -625,7 +625,7 @@ double GridBlock::getLimiterTestValue(double input, void GridBlock::rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { if (!opFlags[has_limits]) { return; @@ -648,7 +648,7 @@ void GridBlock::rootTest(const IOdata& inputs, ChangeCode GridBlock::rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& solverModeValue, + const SolverMode& solverModeValue, CheckLevel /*level*/) { ChangeCode ret = ChangeCode::NO_CHANGE; @@ -683,7 +683,7 @@ ChangeCode GridBlock::rootCheck(const IOdata& inputs, void GridBlock::rootTrigger(coreTime /*time*/, const IOdata& inputs, const std::vector& rootMask, - const solverMode& solverModeValue) + const SolverMode& solverModeValue) { if (!opFlags[has_limits]) { return; diff --git a/src/griddyn/blocks/BlockSequence.cpp b/src/griddyn/blocks/BlockSequence.cpp index 16932025c..7b6ecea70 100644 --- a/src/griddyn/blocks/BlockSequence.cpp +++ b/src/griddyn/blocks/BlockSequence.cpp @@ -107,7 +107,7 @@ void BlockSequence::add(GridBlock* blk) void BlockSequence::updateLocalCache(const IOdata& /*inputs*/, const stateData& stateData, - const solverMode& sMode) + const SolverMode& sMode) { if (!stateData.updateRequired(seqID)) { return; @@ -148,7 +148,7 @@ void BlockSequence::blockResidual(double input, double didt, const stateData& stateData, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(noInputs, stateData, sMode); auto cnt = static_cast(sequence.size()); @@ -166,7 +166,7 @@ void BlockSequence::blockDerivative(double input, double didt, const stateData& stateData, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(noInputs, stateData, sMode); auto cnt = static_cast(sequence.size()); @@ -183,7 +183,7 @@ void BlockSequence::blockDerivative(double input, void BlockSequence::blockAlgebraicUpdate(double input, const stateData& stateData, double update[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(noInputs, stateData, sMode); auto cnt = static_cast(sequence.size()); @@ -200,7 +200,7 @@ void BlockSequence::blockJacobianElements(double input, const stateData& stateData, matrixData& matrixDataRef, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(noInputs, stateData, sMode); const size_t cnt = sequence.size(); @@ -220,7 +220,7 @@ void BlockSequence::blockJacobianElements(double input, void BlockSequence::rootTest(const IOdata& inputs, const stateData& stateData, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(noInputs, stateData, sMode); const size_t cnt = sequence.size(); @@ -237,7 +237,7 @@ void BlockSequence::rootTest(const IOdata& inputs, void BlockSequence::rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { const size_t cnt = sequence.size(); IOdata inAct{inputs.empty() ? kNullVal : inputs[0] + bias, getRateInput(inputs)}; @@ -252,7 +252,7 @@ void BlockSequence::rootTrigger(coreTime time, ChangeCode BlockSequence::rootCheck(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { ChangeCode ret = ChangeCode::NO_CHANGE; diff --git a/src/griddyn/blocks/BlockSequence.h b/src/griddyn/blocks/BlockSequence.h index 603845b83..acf784d19 100644 --- a/src/griddyn/blocks/BlockSequence.h +++ b/src/griddyn/blocks/BlockSequence.h @@ -55,38 +55,38 @@ class BlockSequence: public GridBlock { double didt, const stateData& stateData, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockDerivative(double input, double didt, const stateData& stateData, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockAlgebraicUpdate(double input, const stateData& stateData, double update[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockJacobianElements(double input, double didt, const stateData& stateData, matrixData& matrixDataRef, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double input) override; virtual void rootTest(const IOdata& inputs, const stateData& stateData, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; // virtual void setTime(coreTime time){prevTime=time;}; /** get the output of one of the component blocks @@ -102,7 +102,7 @@ class BlockSequence: public GridBlock { virtual void updateLocalCache(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual CoreObject* getSubObject(std::string_view typeName, index_t num) const override; diff --git a/src/griddyn/blocks/ControlBlock.cpp b/src/griddyn/blocks/ControlBlock.cpp index 11b92fe74..77d3757f2 100644 --- a/src/griddyn/blocks/ControlBlock.cpp +++ b/src/griddyn/blocks/ControlBlock.cpp @@ -76,7 +76,7 @@ void ControlBlock::dynObjectInitializeB(const IOdata& inputs, void ControlBlock::blockAlgebraicUpdate(double input, const stateData& stateDataRef, double update[], - const solverMode& sMode) + const SolverMode& sMode) { if (!opFlags[differential_input]) { auto locationData = offsets.getLocations(stateDataRef, update, sMode, this); @@ -93,7 +93,7 @@ void ControlBlock::blockDerivative(double input, double didt, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto locationData = offsets.getLocations(stateDataRef, deriv, sMode, this); if (opFlags[differential_input]) { @@ -115,7 +115,7 @@ void ControlBlock::blockJacobianElements(double input, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { auto locationData = offsets.getLocations(stateDataRef, sMode, this); if (opFlags[differential_input]) { @@ -192,7 +192,7 @@ double ControlBlock::step(coreTime time, double input) return out; } -index_t ControlBlock::findIndex(std::string_view field, const solverMode& sMode) const +index_t ControlBlock::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if (field == "m1") { diff --git a/src/griddyn/blocks/ControlBlock.h b/src/griddyn/blocks/ControlBlock.h index 7f22f92b9..b0e8248ce 100644 --- a/src/griddyn/blocks/ControlBlock.h +++ b/src/griddyn/blocks/ControlBlock.h @@ -47,24 +47,24 @@ class ControlBlock: public GridBlock { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void blockDerivative(double input, double didt, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockAlgebraicUpdate(double input, const stateData& stateDataRef, double update[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void blockJacobianElements(double input, double didt, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double input) override; // virtual void setTime(coreTime time){prevTime=time;}; virtual stringVec localStateNames() const override; diff --git a/src/griddyn/blocks/DeadbandBlock.cpp b/src/griddyn/blocks/DeadbandBlock.cpp index c7528ed63..e2873dae1 100644 --- a/src/griddyn/blocks/DeadbandBlock.cpp +++ b/src/griddyn/blocks/DeadbandBlock.cpp @@ -207,7 +207,7 @@ void DeadbandBlock::blockDerivative(double input, double didt, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { if (opFlags[differential_input]) { auto offset = offsets.getDiffOffset(sMode) + limiter_diff; @@ -224,7 +224,7 @@ void DeadbandBlock::blockDerivative(double input, void DeadbandBlock::blockAlgebraicUpdate(double input, const stateData& stateDataRef, double update[], - const solverMode& sMode) + const SolverMode& sMode) { if (!opFlags[differential_input]) { auto offset = offsets.getAlgOffset(sMode) + limiter_alg; @@ -244,7 +244,7 @@ void DeadbandBlock::blockJacobianElements(double input, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { if ((!opFlags[differential_input]) && (hasAlgebraic(sMode))) { auto offset = offsets.getAlgOffset(sMode) + limiter_alg; @@ -275,7 +275,7 @@ void DeadbandBlock::blockJacobianElements(double input, void DeadbandBlock::rootTest(const IOdata& inputs, const stateData& stateDataRef, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { if (limiter_alg + limiter_diff > 0) { GridBlock::rootTest(inputs, stateDataRef, roots, sMode); @@ -337,7 +337,7 @@ void DeadbandBlock::rootTest(const IOdata& inputs, void DeadbandBlock::rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { auto rootOffset = offsets.getRootOffset(sMode); if (limiter_alg + limiter_diff > 0) { @@ -405,7 +405,7 @@ void DeadbandBlock::rootTrigger(coreTime time, ChangeCode DeadbandBlock::rootCheck(const IOdata& inputs, const stateData& stateDataRef, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel /*level*/) { ChangeCode ret = ChangeCode::NO_CHANGE; diff --git a/src/griddyn/blocks/DeadbandBlock.h b/src/griddyn/blocks/DeadbandBlock.h index cf4532ce5..b92df24b1 100644 --- a/src/griddyn/blocks/DeadbandBlock.h +++ b/src/griddyn/blocks/DeadbandBlock.h @@ -58,38 +58,38 @@ class DeadbandBlock: public GridBlock { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - // virtual index_t findIndex(const std::string &field, const solverMode &sMode) const; + // virtual index_t findIndex(const std::string &field, const SolverMode &sMode) const; // virtual void derivative(const IOdata &inputs, const stateData &sD, double deriv[], const - // solverMode &sMode); + // SolverMode &sMode); virtual void blockDerivative(double input, double didt, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockAlgebraicUpdate(double input, const stateData& stateDataRef, double update[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockJacobianElements(double input, double didt, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double input) override; virtual void rootTest(const IOdata& inputs, const stateData& stateDataRef, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateDataRef, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; /** @brief get the deadband state @return the state of the deadband block diff --git a/src/griddyn/blocks/DelayBlock.cpp b/src/griddyn/blocks/DelayBlock.cpp index a63727404..2c69851da 100644 --- a/src/griddyn/blocks/DelayBlock.cpp +++ b/src/griddyn/blocks/DelayBlock.cpp @@ -122,7 +122,7 @@ void DelayBlock::blockDerivative(double input, double didt, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getDiffOffset(sMode) + limiter_diff; @@ -137,7 +137,7 @@ void DelayBlock::blockJacobianElements(double input, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { if ((isAlgebraicOnly(sMode)) || (opFlags[simplified])) { GridBlock::blockJacobianElements(input, didt, stateDataRef, jacobian, argLoc, sMode); diff --git a/src/griddyn/blocks/DelayBlock.h b/src/griddyn/blocks/DelayBlock.h index 7bf82af7a..7bf104464 100644 --- a/src/griddyn/blocks/DelayBlock.h +++ b/src/griddyn/blocks/DelayBlock.h @@ -44,20 +44,20 @@ class DelayBlock: public GridBlock { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - // virtual index_t findIndex(const std::string &field, const solverMode &sMode) const; + // virtual index_t findIndex(const std::string &field, const SolverMode &sMode) const; virtual void blockDerivative(double input, double didt, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void blockJacobianElements(double input, double didt, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double inputA) override; // virtual void setTime(coreTime time){prevTime=time;}; }; diff --git a/src/griddyn/blocks/DerivativeBlock.cpp b/src/griddyn/blocks/DerivativeBlock.cpp index 59fd609ef..ef574d194 100644 --- a/src/griddyn/blocks/DerivativeBlock.cpp +++ b/src/griddyn/blocks/DerivativeBlock.cpp @@ -111,7 +111,7 @@ double DerivativeBlock::step(coreTime time, double inputA) void DerivativeBlock::blockAlgebraicUpdate(double input, const stateData& stateDataRef, double update[], - const solverMode& sMode) + const SolverMode& sMode) { auto locationData = offsets.getLocations(stateDataRef, update, sMode, this); locationData.destLoc[limiter_alg] = locationData.dstateLoc[0]; @@ -124,7 +124,7 @@ void DerivativeBlock::blockDerivative(double input, double /*didt*/, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getDiffOffset(sMode); // limiter diff must be 0 since the output is algebraic @@ -137,7 +137,7 @@ void DerivativeBlock::blockJacobianElements(double input, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getDiffOffset(sMode); if (hasDifferential(sMode)) { diff --git a/src/griddyn/blocks/DerivativeBlock.h b/src/griddyn/blocks/DerivativeBlock.h index 0182f9e4d..678010b4f 100644 --- a/src/griddyn/blocks/DerivativeBlock.h +++ b/src/griddyn/blocks/DerivativeBlock.h @@ -36,24 +36,24 @@ class DerivativeBlock: public GridBlock { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - // virtual index_t findIndex(const std::string &field, const solverMode &sMode) const; + // virtual index_t findIndex(const std::string &field, const SolverMode &sMode) const; virtual void blockDerivative(double input, double didt, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockAlgebraicUpdate(double input, const stateData& stateDataRef, double update[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void blockJacobianElements(double input, double didt, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double inputA) override; virtual stringVec localStateNames() const override; diff --git a/src/griddyn/blocks/FilteredDerivativeBlock.cpp b/src/griddyn/blocks/FilteredDerivativeBlock.cpp index ee8548aab..2712cbe74 100644 --- a/src/griddyn/blocks/FilteredDerivativeBlock.cpp +++ b/src/griddyn/blocks/FilteredDerivativeBlock.cpp @@ -122,7 +122,7 @@ void FilteredDerivativeBlock::blockDerivative(double input, double /*didt*/, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getDiffOffset(sMode) + limiter_diff; @@ -135,7 +135,7 @@ void FilteredDerivativeBlock::blockJacobianElements(double input, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { if (!hasDifferential(sMode)) { return; diff --git a/src/griddyn/blocks/FilteredDerivativeBlock.h b/src/griddyn/blocks/FilteredDerivativeBlock.h index 1ed8fe23b..a16e0c9f0 100644 --- a/src/griddyn/blocks/FilteredDerivativeBlock.h +++ b/src/griddyn/blocks/FilteredDerivativeBlock.h @@ -40,20 +40,20 @@ class FilteredDerivativeBlock: public GridBlock { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - // virtual index_t findIndex(const std::string &field, const solverMode &sMode) const; + // virtual index_t findIndex(const std::string &field, const SolverMode &sMode) const; virtual void blockDerivative(double input, double didt, const stateData& stateDataRef, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void blockJacobianElements(double input, double didt, const stateData& stateDataRef, matrixData& jacobian, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double inputA) override; virtual stringVec localStateNames() const override; diff --git a/src/griddyn/blocks/FunctionBlock.cpp b/src/griddyn/blocks/FunctionBlock.cpp index f14d6181b..2e04d0fc2 100644 --- a/src/griddyn/blocks/FunctionBlock.cpp +++ b/src/griddyn/blocks/FunctionBlock.cpp @@ -66,7 +66,7 @@ void FunctionBlock::dynObjectInitializeB(const IOdata& inputs, void FunctionBlock::blockAlgebraicUpdate(double input, const stateData& stateDataValue, double update[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode) + limiter_alg; if (opFlags[USES_CONSTANT_ARG]) { @@ -84,7 +84,7 @@ void FunctionBlock::blockJacobianElements(double input, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode) + limiter_alg; // use the md.assign Macro defined in basicDefs @@ -169,7 +169,7 @@ void FunctionBlock::setFunction(const std::string& functionName) /* double FunctionBlock::currentValue(const IOdata &inputs, const stateData &sD, -const solverMode &sMode) const +const SolverMode &sMode) const { auto Loc; offsets.getLocations(sD, sMode, &Loc, this); diff --git a/src/griddyn/blocks/FunctionBlock.h b/src/griddyn/blocks/FunctionBlock.h index fa7938707..2ecf02470 100644 --- a/src/griddyn/blocks/FunctionBlock.h +++ b/src/griddyn/blocks/FunctionBlock.h @@ -46,14 +46,14 @@ class FunctionBlock: public GridBlock { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - // virtual index_t findIndex(const std::string &field, const solverMode &sMode) const; + // virtual index_t findIndex(const std::string &field, const SolverMode &sMode) const; // virtual void blockDerivative(double input, double didt, const stateData &sD, double - // deriv[], const solverMode &sMode) override; + // deriv[], const SolverMode &sMode) override; virtual void blockAlgebraicUpdate(double input, const stateData& stateDataValue, double update[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void blockJacobianElements(double input, @@ -61,7 +61,7 @@ class FunctionBlock: public GridBlock { const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double input) override; // virtual void setTime(coreTime time){prevTime=time;}; protected: diff --git a/src/griddyn/blocks/IntegralBlock.cpp b/src/griddyn/blocks/IntegralBlock.cpp index 2116a3fa0..a7bc288e3 100644 --- a/src/griddyn/blocks/IntegralBlock.cpp +++ b/src/griddyn/blocks/IntegralBlock.cpp @@ -55,7 +55,7 @@ void IntegralBlock::blockResidual(double input, double didt, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { GridBlock::blockResidual(input, didt, stateDataValue, resid, sMode); @@ -70,7 +70,7 @@ void IntegralBlock::blockDerivative(double input, double didt, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getDiffOffset(sMode); deriv[offset + limiter_diff] = K * (input + bias); @@ -84,7 +84,7 @@ void IntegralBlock::blockJacobianElements(double input, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { GridBlock::blockJacobianElements( diff --git a/src/griddyn/blocks/IntegralBlock.h b/src/griddyn/blocks/IntegralBlock.h index 24aafac4d..05e21c203 100644 --- a/src/griddyn/blocks/IntegralBlock.h +++ b/src/griddyn/blocks/IntegralBlock.h @@ -33,27 +33,27 @@ class IntegralBlock: public GridBlock { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - // virtual index_t findIndex(const std::string &field, const solverMode &sMode) const; + // virtual index_t findIndex(const std::string &field, const SolverMode &sMode) const; virtual void blockDerivative(double input, double didt, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockResidual(double input, double didt, const stateData& stateDataValue, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void blockJacobianElements(double input, double didt, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double inputA) override; - // virtual void timestep(coreTime time, const IOdata &inputs, const solverMode &sMode); + // virtual void timestep(coreTime time, const IOdata &inputs, const SolverMode &sMode); // virtual void setTime(coreTime time){prevTime=time;}; }; } // namespace griddyn::blocks diff --git a/src/griddyn/blocks/LutBlock.cpp b/src/griddyn/blocks/LutBlock.cpp index 8af148c1c..15e53c3bb 100644 --- a/src/griddyn/blocks/LutBlock.cpp +++ b/src/griddyn/blocks/LutBlock.cpp @@ -52,7 +52,7 @@ void LutBlock::dynObjectInitializeB(const IOdata& inputs, void LutBlock::blockAlgebraicUpdate(double input, const stateData& stateDataValue, double update[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode) + limiter_alg; update[offset] = K * computeValue(input + bias); @@ -67,7 +67,7 @@ void LutBlock::blockJacobianElements(double input, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode) + limiter_alg; // use the md.assign Macro defined in basicDefs diff --git a/src/griddyn/blocks/LutBlock.h b/src/griddyn/blocks/LutBlock.h index 25bc4f995..4346e7c07 100644 --- a/src/griddyn/blocks/LutBlock.h +++ b/src/griddyn/blocks/LutBlock.h @@ -37,15 +37,15 @@ class LutBlock: public GridBlock { virtual void blockAlgebraicUpdate(double input, const stateData& stateDataValue, double update[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // virtual double blockResidual (double input, double didt, const stateData &sD, double - // resid[], const solverMode &sMode) override; + // resid[], const SolverMode &sMode) override; virtual void blockJacobianElements(double input, double didt, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double input) override; // virtual void setTime(coreTime time){prevTime=time;}; double computeValue(double input); diff --git a/src/griddyn/blocks/NullBlock.cpp b/src/griddyn/blocks/NullBlock.cpp index 2bd8f25f5..da0b42cef 100644 --- a/src/griddyn/blocks/NullBlock.cpp +++ b/src/griddyn/blocks/NullBlock.cpp @@ -57,7 +57,7 @@ void NullBlock::dynObjectInitializeB(const IOdata& inputs, fieldSet[0] = prevInput; } -void NullBlock::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void NullBlock::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { step(time, inputs[0]); } @@ -71,7 +71,7 @@ double NullBlock::step(coreTime time, double input) } double NullBlock::getBlockOutput(const stateData& stateDataValue, - const solverMode& solverModeValue) const + const SolverMode& solverModeValue) const { auto locations = offsets.getLocations(stateDataValue, solverModeValue, this); return opFlags[differential_output] ? *locations.diffStateLoc : *locations.algStateLoc; @@ -84,7 +84,7 @@ double NullBlock::getBlockOutput() const } double NullBlock::getBlockDoutDt(const stateData& stateDataValue, - const solverMode& solverModeValue) const + const SolverMode& solverModeValue) const { if (opFlags[differential_output]) { auto locations = offsets.getLocations(stateDataValue, solverModeValue, this); @@ -102,14 +102,14 @@ void NullBlock::blockResidual(double /*input*/, double /*didt*/, const stateData& /*sD*/, double /*resid*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void NullBlock::blockAlgebraicUpdate(double /*input*/, const stateData& /*sD*/, double /*update*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } @@ -117,7 +117,7 @@ void NullBlock::blockDerivative(double /*input*/, double /*didt*/, const stateData& /*sD*/, double /*deriv*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } @@ -126,20 +126,20 @@ void NullBlock::blockJacobianElements(double /*input*/, const stateData& /*sD*/, matrixData& /*md*/, index_t /*argLoc*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void NullBlock::rootTest(const IOdata& /*inputs*/, const stateData& /*sD*/, double /*roots*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } ChangeCode NullBlock::rootCheck(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { return ChangeCode::NO_CHANGE; @@ -148,7 +148,7 @@ ChangeCode NullBlock::rootCheck(const IOdata& /*inputs*/, void NullBlock::rootTrigger(coreTime /*time*/, const IOdata& /*inputs*/, const std::vector& /*rootMask*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } diff --git a/src/griddyn/blocks/NullBlock.h b/src/griddyn/blocks/NullBlock.h index 9bbf4da10..c127f67d6 100644 --- a/src/griddyn/blocks/NullBlock.h +++ b/src/griddyn/blocks/NullBlock.h @@ -39,48 +39,48 @@ class NullBlock final: public GridBlock { double didt, const stateData& stateDataValue, double resid[], - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; virtual void blockDerivative(double input, double didt, const stateData& stateDataValue, double deriv[], - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; virtual void blockAlgebraicUpdate(double input, const stateData& stateDataValue, double update[], - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; virtual void blockJacobianElements(double input, double didt, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual double step(coreTime time, double input) override; virtual void rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& solverModeValue) override; + const SolverMode& solverModeValue) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& solverModeValue, + const SolverMode& solverModeValue, CheckLevel level) override; // virtual void setTime(coreTime time){prevTime=time;}; virtual double getBlockOutput(const stateData& stateDataValue, - const solverMode& solverModeValue) const override; + const SolverMode& solverModeValue) const override; virtual double getBlockOutput() const override; virtual double getBlockDoutDt(const stateData& stateDataValue, - const solverMode& solverModeValue) const override; + const SolverMode& solverModeValue) const override; virtual double getBlockDoutDt() const override; }; diff --git a/src/griddyn/blocks/PidBlock.cpp b/src/griddyn/blocks/PidBlock.cpp index 6e000ade3..2f916d9df 100644 --- a/src/griddyn/blocks/PidBlock.cpp +++ b/src/griddyn/blocks/PidBlock.cpp @@ -104,7 +104,7 @@ void PidBlock::blockDerivative(double input, double didt, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(stateDataValue, deriv, sMode, this); Loc.destDiffLoc[limiter_diff + 2] = m_I * (input + bias); @@ -126,7 +126,7 @@ void PidBlock::blockJacobianElements(double input, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(stateDataValue, nullptr, sMode, this); // adjust the offset to account for the limiter states; @@ -213,7 +213,7 @@ double PidBlock::step(coreTime time, double inputA) return m_output; } -index_t PidBlock::findIndex(std::string_view field, const solverMode& sMode) const +index_t PidBlock::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if (field == "integral") { diff --git a/src/griddyn/blocks/PidBlock.h b/src/griddyn/blocks/PidBlock.h index dc8e47d68..d2df6a6cb 100644 --- a/src/griddyn/blocks/PidBlock.h +++ b/src/griddyn/blocks/PidBlock.h @@ -44,20 +44,20 @@ class PidBlock: public GridBlock { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void blockDerivative(double input, double didt, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void blockJacobianElements(double input, double didt, const stateData& stateDataValue, matrixData& matrixDataValue, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double inputA) override; virtual stringVec localStateNames() const override; }; diff --git a/src/griddyn/blocks/TransferFunctionBlock.cpp b/src/griddyn/blocks/TransferFunctionBlock.cpp index dbb885851..9b59d918f 100644 --- a/src/griddyn/blocks/TransferFunctionBlock.cpp +++ b/src/griddyn/blocks/TransferFunctionBlock.cpp @@ -115,7 +115,7 @@ void TransferFunctionBlock::blockResidual(double input, double didt, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); if (extraOutputState) { @@ -135,7 +135,7 @@ void TransferFunctionBlock::blockDerivative(double input, double didt, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { // auto offset = offsets.getDiffOffset (sMode); // auto Aoffset = offsets.getAlgOffset (sMode); @@ -151,7 +151,7 @@ void TransferFunctionBlock::blockJacobianElements(double input, const stateData& sD, matrixData& md, index_t argLoc, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); md.assign(Loc.algOffset + 1, Loc.algOffset + 1, -1); @@ -212,7 +212,7 @@ double TransferFunctionBlock::step(coreTime time, double inputA) return out; } -index_t TransferFunctionBlock::findIndex(std::string_view field, const solverMode& sMode) const +index_t TransferFunctionBlock::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if (field == "m1") { diff --git a/src/griddyn/blocks/TransferFunctionBlock.h b/src/griddyn/blocks/TransferFunctionBlock.h index d7f6c8044..dec165f16 100644 --- a/src/griddyn/blocks/TransferFunctionBlock.h +++ b/src/griddyn/blocks/TransferFunctionBlock.h @@ -56,25 +56,25 @@ are 0 virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void blockDerivative(double input, double didt, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void blockResidual(double input, double didt, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void blockJacobianElements(double input, double didt, const stateData& sD, matrixData& md, index_t argLoc, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double step(coreTime time, double inputA) override; // virtual void setTime(coreTime time){prevTime=time;}; virtual stringVec localStateNames() const override; diff --git a/src/griddyn/controllers/AGControl.cpp b/src/griddyn/controllers/AGControl.cpp index b34eb114c..2f892773a 100644 --- a/src/griddyn/controllers/AGControl.cpp +++ b/src/griddyn/controllers/AGControl.cpp @@ -106,7 +106,7 @@ CoreObject* AGControl::clone(CoreObject* obj) const double AGControl::getOutput(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t /*outNum*/) const { return reg; @@ -135,7 +135,7 @@ void AGControl::dynObjectInitializeB(const IOdata& inputs, void AGControl::updateA(coreTime /*time*/) {} -void AGControl::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void AGControl::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { prevTime = time; diff --git a/src/griddyn/controllers/AGControl.h b/src/griddyn/controllers/AGControl.h index 52b5d9480..5576050fa 100644 --- a/src/griddyn/controllers/AGControl.h +++ b/src/griddyn/controllers/AGControl.h @@ -70,11 +70,11 @@ class AGControl: public GridSubModel { virtual void updateA(coreTime time) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t num = 0) const override; virtual double getOutput(index_t /*num*/ = 0) const override; diff --git a/src/griddyn/controllers/ControlSystem.cpp b/src/griddyn/controllers/ControlSystem.cpp index a036aaa8d..aaacda733 100644 --- a/src/griddyn/controllers/ControlSystem.cpp +++ b/src/griddyn/controllers/ControlSystem.cpp @@ -70,7 +70,7 @@ void ControlSystem::set(std::string_view param, double val, units::unit unitType } } -index_t ControlSystem::findIndex(std::string_view /*field*/, const solverMode& /*sMode*/) const +index_t ControlSystem::findIndex(std::string_view /*field*/, const SolverMode& /*sMode*/) const { return kInvalidLocation; } @@ -78,7 +78,7 @@ index_t ControlSystem::findIndex(std::string_view /*field*/, const solverMode& / void ControlSystem::residual(const IOdata& /*inputs*/, const stateData& /*sD*/, double /*resid*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } @@ -86,33 +86,33 @@ void ControlSystem::jacobianElements(const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /*md*/, const IOlocs& /*inputLocs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void ControlSystem::timestep(coreTime /*time*/, const IOdata& /*inputs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void ControlSystem::rootTest(const IOdata& /*inputs*/, const stateData& /*sD*/, double /*roots*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void ControlSystem::rootTrigger(coreTime /*time*/, const IOdata& /*inputs*/, const std::vector& /*rootMask*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } ChangeCode ControlSystem::rootCheck(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { return ChangeCode::NO_CHANGE; diff --git a/src/griddyn/controllers/ControlSystem.h b/src/griddyn/controllers/ControlSystem.h index 5aa9961e4..4ccefbeb8 100644 --- a/src/griddyn/controllers/ControlSystem.h +++ b/src/griddyn/controllers/ControlSystem.h @@ -39,32 +39,32 @@ class ControlSystem: public GridSubModel { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; // virtual void setTime(coreTime time){prevTime=time;}; }; diff --git a/src/griddyn/exciters/Exciter.cpp b/src/griddyn/exciters/Exciter.cpp index b14b6d4b2..47e40fa09 100644 --- a/src/griddyn/exciters/Exciter.cpp +++ b/src/griddyn/exciters/Exciter.cpp @@ -101,12 +101,12 @@ void Exciter::dynObjectInitializeB(const IOdata& inputs, void Exciter::residual(const IOdata& inputs, const stateData& stateData, double resid[], - const solverMode& solverMode) + const SolverMode& SolverMode) { - if (isAlgebraicOnly(solverMode)) { + if (isAlgebraicOnly(SolverMode)) { return; } - auto offset = offsets.getDiffOffset(solverMode); + auto offset = offsets.getDiffOffset(SolverMode); const auto* exciterState = stateData.state + offset; const auto* exciterStateDerivatives = stateData.dstate_dt + offset; auto* residualValues = resid + offset; @@ -122,9 +122,9 @@ void Exciter::residual(const IOdata& inputs, void Exciter::derivative(const IOdata& inputs, const stateData& stateData, double deriv[], - const solverMode& solverMode) + const SolverMode& SolverMode) { - auto locations = offsets.getLocations(stateData, deriv, solverMode, this); + auto locations = offsets.getLocations(stateData, deriv, SolverMode, this); const auto* exciterState = locations.diffStateLoc; auto* derivatives = locations.destDiffLoc; if (opFlags[outside_vlim]) { @@ -139,12 +139,12 @@ void Exciter::jacobianElements(const IOdata& /*inputs*/, const stateData& stateData, matrixData& matrix, const IOlocs& inputLocs, - const solverMode& solverMode) + const SolverMode& SolverMode) { - if (isAlgebraicOnly(solverMode)) { + if (isAlgebraicOnly(SolverMode)) { return; } - auto offset = offsets.getDiffOffset(solverMode); + auto offset = offsets.getDiffOffset(SolverMode); if (opFlags[outside_vlim]) { matrix.assign(offset, offset, -stateData.cj); @@ -157,10 +157,10 @@ void Exciter::jacobianElements(const IOdata& /*inputs*/, void Exciter::rootTest(const IOdata& inputs, const stateData& stateData, double root[], - const solverMode& solverMode) + const SolverMode& SolverMode) { - auto offset = offsets.getDiffOffset(solverMode); - const auto rootOffset = offsets.getRootOffset(solverMode); + auto offset = offsets.getDiffOffset(SolverMode); + const auto rootOffset = offsets.getRootOffset(SolverMode); const double eField = stateData.state[offset]; if (opFlags[outside_vlim]) { @@ -176,9 +176,9 @@ void Exciter::rootTest(const IOdata& inputs, void Exciter::rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& solverMode) + const SolverMode& SolverMode) { - const auto rootOffset = offsets.getRootOffset(solverMode); + const auto rootOffset = offsets.getRootOffset(SolverMode); if (rootMask[rootOffset] != 0) { if (opFlags[outside_vlim]) { logging::normal(this, "root trigger back in bounds"); @@ -204,7 +204,7 @@ void Exciter::rootTrigger(coreTime time, ChangeCode Exciter::rootCheck(const IOdata& inputs, const stateData& /*stateData*/, - const solverMode& /*solverMode*/, + const SolverMode& /*SolverMode*/, CheckLevel /*level*/) { const double eField = m_state[0]; diff --git a/src/griddyn/exciters/ExciterDC1A.cpp b/src/griddyn/exciters/ExciterDC1A.cpp index 94c9bd739..c1642ca89 100644 --- a/src/griddyn/exciters/ExciterDC1A.cpp +++ b/src/griddyn/exciters/ExciterDC1A.cpp @@ -75,7 +75,7 @@ void ExciterDC1A::dynObjectInitializeB(const IOdata& inputs, void ExciterDC1A::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -93,7 +93,7 @@ void ExciterDC1A::residual(const IOdata& inputs, void ExciterDC1A::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* es = Loc.diffStateLoc; @@ -116,7 +116,7 @@ void ExciterDC1A::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -173,7 +173,7 @@ void ExciterDC1A::limitJacobian(double /*V*/, void ExciterDC1A::rootTest(const IOdata& inputs, const stateData& sD, double root[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); const double* es = sD.state + offset; @@ -193,7 +193,7 @@ void ExciterDC1A::rootTest(const IOdata& inputs, ChangeCode ExciterDC1A::rootCheck(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { double* es = m_state.data(); diff --git a/src/griddyn/exciters/ExciterDC1A.h b/src/griddyn/exciters/ExciterDC1A.h index 1513df22d..14983375d 100644 --- a/src/griddyn/exciters/ExciterDC1A.h +++ b/src/griddyn/exciters/ExciterDC1A.h @@ -34,24 +34,24 @@ class ExciterDC1A: public ExciterIEEEtype1 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double root[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; // virtual void setTime(coreTime time){prevTime=time;}; protected: diff --git a/src/griddyn/exciters/ExciterDC2A.cpp b/src/griddyn/exciters/ExciterDC2A.cpp index 73687025d..46ed486e5 100644 --- a/src/griddyn/exciters/ExciterDC2A.cpp +++ b/src/griddyn/exciters/ExciterDC2A.cpp @@ -50,7 +50,7 @@ CoreObject* ExciterDC2A::clone(CoreObject* obj) const void ExciterDC2A::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -74,7 +74,7 @@ void ExciterDC2A::residual(const IOdata& inputs, void ExciterDC2A::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -116,7 +116,7 @@ void ExciterDC2A::limitJacobian(double /*V*/, void ExciterDC2A::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getDiffOffset(sMode); int rootOffset = offsets.getRootOffset(sMode); @@ -135,7 +135,7 @@ void ExciterDC2A::rootTest(const IOdata& inputs, ChangeCode ExciterDC2A::rootCheck(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { double* es = m_state.data(); diff --git a/src/griddyn/exciters/ExciterDC2A.h b/src/griddyn/exciters/ExciterDC2A.h index 45f322386..61c51aeb1 100644 --- a/src/griddyn/exciters/ExciterDC2A.h +++ b/src/griddyn/exciters/ExciterDC2A.h @@ -20,18 +20,18 @@ class ExciterDC2A: public ExciterDC1A { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; protected: diff --git a/src/griddyn/exciters/ExciterIEEEtype1.cpp b/src/griddyn/exciters/ExciterIEEEtype1.cpp index 3e0a844e3..197c7e263 100644 --- a/src/griddyn/exciters/ExciterIEEEtype1.cpp +++ b/src/griddyn/exciters/ExciterIEEEtype1.cpp @@ -69,7 +69,7 @@ void ExciterIEEEtype1::dynObjectInitializeB(const IOdata& inputs, void ExciterIEEEtype1::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (!hasDifferential(sMode)) { return; @@ -94,7 +94,7 @@ void ExciterIEEEtype1::residual(const IOdata& inputs, rv[2] = (-es[2] + es[0] * Kf / Tf) / Tf - esp[2]; } -void ExciterIEEEtype1::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void ExciterIEEEtype1::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { derivative(inputs, emptyStateData, m_dstate_dt.data(), cLocalSolverMode); double dt = time - prevTime; // convert from a coreTime @@ -107,7 +107,7 @@ void ExciterIEEEtype1::timestep(coreTime time, const IOdata& inputs, const solve void ExciterIEEEtype1::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* es = Loc.diffStateLoc; @@ -128,7 +128,7 @@ void ExciterIEEEtype1::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (!hasDifferential(sMode)) { return; @@ -164,7 +164,7 @@ void ExciterIEEEtype1::jacobianElements(const IOdata& /*inputs*/, void ExciterIEEEtype1::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getDiffOffset(sMode); auto rootOffset = offsets.getRootOffset(sMode); @@ -185,7 +185,7 @@ void ExciterIEEEtype1::rootTest(const IOdata& inputs, ChangeCode ExciterIEEEtype1::rootCheck(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { const double* es = m_state.data(); diff --git a/src/griddyn/exciters/ExciterIEEEtype1.h b/src/griddyn/exciters/ExciterIEEEtype1.h index b5548e181..910658e83 100644 --- a/src/griddyn/exciters/ExciterIEEEtype1.h +++ b/src/griddyn/exciters/ExciterIEEEtype1.h @@ -34,29 +34,29 @@ class ExciterIEEEtype1: public Exciter { virtual stringVec localStateNames() const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; }; diff --git a/src/griddyn/exciters/ExciterIEEEtype2.cpp b/src/griddyn/exciters/ExciterIEEEtype2.cpp index 7011c42fc..846e8e69a 100644 --- a/src/griddyn/exciters/ExciterIEEEtype2.cpp +++ b/src/griddyn/exciters/ExciterIEEEtype2.cpp @@ -57,7 +57,7 @@ void ExciterIEEEtype2::dynObjectInitializeB(const IOdata& inputs, void ExciterIEEEtype2::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -84,7 +84,7 @@ void ExciterIEEEtype2::residual(const IOdata& inputs, void ExciterIEEEtype2::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* es = Loc.diffStateLoc; @@ -106,7 +106,7 @@ void ExciterIEEEtype2::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -155,7 +155,7 @@ stringVec ExciterIEEEtype2::localStateNames() const void ExciterIEEEtype2::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); int rootOffset = offsets.getRootOffset(sMode); @@ -174,7 +174,7 @@ void ExciterIEEEtype2::rootTest(const IOdata& inputs, ChangeCode ExciterIEEEtype2::rootCheck(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { double* es = m_state.data(); diff --git a/src/griddyn/exciters/ExciterIEEEtype2.h b/src/griddyn/exciters/ExciterIEEEtype2.h index ecb224b88..244814361 100644 --- a/src/griddyn/exciters/ExciterIEEEtype2.h +++ b/src/griddyn/exciters/ExciterIEEEtype2.h @@ -32,24 +32,24 @@ class ExciterIEEEtype2: public ExciterIEEEtype1 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; // virtual void setTime(coreTime time){prevTime=time;}; }; diff --git a/src/griddyn/exciters/ExciterSEXS.cpp b/src/griddyn/exciters/ExciterSEXS.cpp index d7fd0fe35..759d7e836 100644 --- a/src/griddyn/exciters/ExciterSEXS.cpp +++ b/src/griddyn/exciters/ExciterSEXS.cpp @@ -99,15 +99,15 @@ double ExciterSEXS::regulatorOutput(const IOdata& inputs, const double stateX) c void ExciterSEXS::residual(const IOdata& inputs, const stateData& stateData, double resid[], - const solverMode& solverMode) + const SolverMode& SolverMode) { - if (!hasDifferential(solverMode)) { + if (!hasDifferential(SolverMode)) { return; } - derivative(inputs, stateData, resid, solverMode); + derivative(inputs, stateData, resid, SolverMode); - auto offset = offsets.getDiffOffset(solverMode); + auto offset = offsets.getDiffOffset(SolverMode); const auto* stateDerivatives = stateData.dstate_dt + offset; resid[offset] -= stateDerivatives[0]; resid[offset + 1] -= stateDerivatives[1]; @@ -116,9 +116,9 @@ void ExciterSEXS::residual(const IOdata& inputs, void ExciterSEXS::derivative(const IOdata& inputs, const stateData& stateData, double deriv[], - const solverMode& solverMode) + const SolverMode& SolverMode) { - auto locations = offsets.getLocations(stateData, deriv, solverMode, this); + auto locations = offsets.getLocations(stateData, deriv, SolverMode, this); const auto* exciterState = locations.diffStateLoc; auto* derivatives = locations.destDiffLoc; @@ -140,13 +140,13 @@ void ExciterSEXS::jacobianElements(const IOdata& /*inputs*/, const stateData& stateData, matrixData& matrix, const IOlocs& inputLocs, - const solverMode& solverMode) + const SolverMode& SolverMode) { - if (!hasDifferential(solverMode)) { + if (!hasDifferential(SolverMode)) { return; } - auto offset = offsets.getDiffOffset(solverMode); + auto offset = offsets.getDiffOffset(SolverMode); const auto invTe = (Te != 0.0) ? (1.0 / Te) : 0.0; const auto invTb = (Tb != 0.0) ? (1.0 / Tb) : 0.0; matrix.assign(offset, offset, -invTe - stateData.cj); @@ -165,10 +165,10 @@ void ExciterSEXS::jacobianElements(const IOdata& /*inputs*/, void ExciterSEXS::rootTest(const IOdata& inputs, const stateData& stateData, double root[], - const solverMode& solverMode) + const SolverMode& SolverMode) { - auto offset = offsets.getDiffOffset(solverMode); - auto rootOffset = offsets.getRootOffset(solverMode); + auto offset = offsets.getDiffOffset(SolverMode); + auto rootOffset = offsets.getRootOffset(SolverMode); const auto regulatorVoltage = regulatorOutput(inputs, stateData.state[offset + 1]); if (opFlags[outside_vlim]) { @@ -185,9 +185,9 @@ void ExciterSEXS::rootTest(const IOdata& inputs, void ExciterSEXS::rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& solverMode) + const SolverMode& SolverMode) { - auto rootOffset = offsets.getRootOffset(solverMode); + auto rootOffset = offsets.getRootOffset(SolverMode); if (rootMask[rootOffset] == 0) { return; } @@ -208,12 +208,12 @@ void ExciterSEXS::rootTrigger(coreTime time, } const stateData state(time, m_state.data()); - derivative(inputs, state, m_dstate_dt.data(), solverMode); + derivative(inputs, state, m_dstate_dt.data(), SolverMode); } ChangeCode ExciterSEXS::rootCheck(const IOdata& inputs, const stateData& /*stateData*/, - const solverMode& /*solverMode*/, + const SolverMode& /*SolverMode*/, CheckLevel /*level*/) { const auto regulatorVoltage = regulatorOutput(inputs, m_state[1]); diff --git a/src/griddyn/exciters/ExciterSEXS.h b/src/griddyn/exciters/ExciterSEXS.h index 6e65313f3..78c3f4b0c 100644 --- a/src/griddyn/exciters/ExciterSEXS.h +++ b/src/griddyn/exciters/ExciterSEXS.h @@ -42,28 +42,28 @@ class ExciterSEXS: public Exciter { void residual(const IOdata& inputs, const stateData& stateData, double resid[], - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; void derivative(const IOdata& inputs, const stateData& stateData, double deriv[], - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; void jacobianElements(const IOdata& inputs, const stateData& stateData, matrixData& matrix, const IOlocs& inputLocs, - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; void rootTest(const IOdata& inputs, const stateData& stateData, double root[], - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& solverMode) override; + const SolverMode& SolverMode) override; ChangeCode rootCheck(const IOdata& inputs, const stateData& stateData, - const solverMode& solverMode, + const SolverMode& SolverMode, CheckLevel level) override; private: diff --git a/src/griddyn/generators/DynamicGenerator.cpp b/src/griddyn/generators/DynamicGenerator.cpp index 7e46bfa7c..5349acf6a 100644 --- a/src/griddyn/generators/DynamicGenerator.cpp +++ b/src/griddyn/generators/DynamicGenerator.cpp @@ -320,7 +320,7 @@ void DynamicGenerator::dynObjectInitializeB(const IOdata& inputs, void DynamicGenerator::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { for (auto* subobj : getSubObjects()) { @@ -341,7 +341,7 @@ void DynamicGenerator::setState(coreTime time, void DynamicGenerator::updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if ((isDynamic(sMode)) && (stateDataValue.updateRequired(subInputs.seqID))) { generateSubModelInputs(inputs, stateDataValue, sMode); // generate current input values @@ -370,7 +370,7 @@ void DynamicGenerator::updateLocalCache(const IOdata& inputs, void DynamicGenerator::guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { for (auto* subobj : getSubObjects()) { @@ -487,7 +487,7 @@ void DynamicGenerator::set(std::string_view param, std::string_view val) } } -void DynamicGenerator::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void DynamicGenerator::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { Generator::timestep(time, inputs, sMode); if (isDynamic(sMode)) { @@ -528,7 +528,7 @@ void DynamicGenerator::timestep(coreTime time, const IOdata& inputs, const solve void DynamicGenerator::algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { if (!isDynamic(sMode)) { // the bus is managing a remote bus voltage @@ -699,7 +699,7 @@ void DynamicGenerator::set(std::string_view param, double val, unit unitType) void DynamicGenerator::outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!isDynamic(sMode)) { // the bus is managing a remote bus voltage if (stateSize(sMode) > 0) { @@ -724,7 +724,7 @@ void DynamicGenerator::outputPartialDerivatives(const IOdata& inputs, sMode); } -count_t DynamicGenerator::outputDependencyCount(index_t num, const solverMode& sMode) const +count_t DynamicGenerator::outputDependencyCount(index_t num, const SolverMode& sMode) const { if (!isDynamic(sMode)) { // the bus is managing a remote bus voltage if (stateSize(sMode) > 0) { @@ -745,7 +745,7 @@ void DynamicGenerator::ioPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { const double scale = machineBasePower / systemBasePower; @@ -762,7 +762,7 @@ void DynamicGenerator::ioPartialDerivatives(const IOdata& inputs, IOdata DynamicGenerator::getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { if (isDynamic(sMode)) // use as a proxy for dynamic state { @@ -777,7 +777,7 @@ IOdata DynamicGenerator::getOutputs(const IOdata& inputs, double DynamicGenerator::getRealPower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { if (isDynamic(sMode)) // use as a proxy for dynamic state { @@ -792,7 +792,7 @@ double DynamicGenerator::getRealPower(const IOdata& inputs, } double DynamicGenerator::getReactivePower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { if (isDynamic(sMode)) // use as a proxy for dynamic state { @@ -808,7 +808,7 @@ double DynamicGenerator::getReactivePower(const IOdata& inputs, void DynamicGenerator::residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (!isDynamic(sMode)) { // the bus is managing a remote bus voltage Generator::residual(inputs, stateDataValue, resid, sMode); @@ -829,7 +829,7 @@ void DynamicGenerator::residual(const IOdata& inputs, void DynamicGenerator::derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(inputs, stateDataValue, sMode); // compute the residuals @@ -847,7 +847,7 @@ void DynamicGenerator::jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (!isDynamic(sMode)) { // the bus is managing a remote bus voltage Generator::jacobianElements(inputs, stateDataValue, matrixDataValue, inputLocs, sMode); @@ -872,7 +872,7 @@ void DynamicGenerator::jacobianElements(const IOdata& inputs, } void DynamicGenerator::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { if ((!isDynamic(sMode)) && (stateSize(sMode) > 0)) { @@ -884,7 +884,7 @@ void DynamicGenerator::getStateName(stringVec& stNames, void DynamicGenerator::rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(inputs, stateDataValue, sMode); @@ -897,7 +897,7 @@ void DynamicGenerator::rootTest(const IOdata& inputs, ChangeCode DynamicGenerator::rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { auto ret = ChangeCode::NO_CHANGE; @@ -916,7 +916,7 @@ ChangeCode DynamicGenerator::rootCheck(const IOdata& inputs, void DynamicGenerator::rootTrigger(coreTime time, const IOdata& /*inputs*/, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { for (auto* sub : getSubObjects()) { if (sub->checkFlag(has_roots)) { @@ -925,7 +925,7 @@ void DynamicGenerator::rootTrigger(coreTime time, } } -index_t DynamicGenerator::findIndex(std::string_view field, const solverMode& sMode) const +index_t DynamicGenerator::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; for (auto* subobj : getSubObjects()) { @@ -978,14 +978,14 @@ CoreObject* DynamicGenerator::getSubObject(std::string_view typeName, index_t nu } double DynamicGenerator::getFreq(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset) const { return genModel->getFreq(stateDataValue, sMode, freqOffset); } double DynamicGenerator::getAngle(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset) const { return genModel->getAngle(stateDataValue, sMode, angleOffset); @@ -1013,7 +1013,7 @@ DynamicGenerator::subModelInputLocs::subModelInputLocs(): void DynamicGenerator::generateSubModelInputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!stateDataValue.updateRequired(subInputs.seqID)) { return; @@ -1075,7 +1075,7 @@ void DynamicGenerator::generateSubModelInputs(const IOdata& inputs, void DynamicGenerator::generateSubModelInputLocs(const IOlocs& inputLocs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!stateDataValue.updateRequired(subInputLocs.seqID)) { return; @@ -1122,7 +1122,7 @@ void DynamicGenerator::generateSubModelInputLocs(const IOlocs& inputLocs, double DynamicGenerator::pSetControlUpdate(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { double val; if (pSetControl != nullptr) { @@ -1143,16 +1143,16 @@ double DynamicGenerator::pSetControlUpdate(const IOdata& inputs, double DynamicGenerator::vSetControlUpdate(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { return (vSetControl != nullptr) ? vSetControl->getOutput(inputs, stateDataValue, sMode) : 1.0; } -index_t DynamicGenerator::pSetLocation(const solverMode& sMode) +index_t DynamicGenerator::pSetLocation(const SolverMode& sMode) { return (pSetControl != nullptr) ? pSetControl->getOutputLoc(sMode) : kNullLocation; } -index_t DynamicGenerator::vSetLocation(const solverMode& sMode) +index_t DynamicGenerator::vSetLocation(const SolverMode& sMode) { return (vSetControl != nullptr) ? vSetControl->getOutputLoc(sMode) : kNullLocation; } diff --git a/src/griddyn/generators/DynamicGenerator.h b/src/griddyn/generators/DynamicGenerator.h index cecb449b1..9d2c8454b 100644 --- a/src/griddyn/generators/DynamicGenerator.h +++ b/src/griddyn/generators/DynamicGenerator.h @@ -83,14 +83,14 @@ class DynamicGenerator: public Generator { virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; // for saving the state + const SolverMode& sMode) override; // for saving the state virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; // for initial setting of the state + const SolverMode& sMode) override; // for initial setting of the state virtual void updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; @@ -107,84 +107,84 @@ class DynamicGenerator: public Generator { virtual void algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; virtual void residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual void derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; using Generator::getReactivePower; using Generator::getRealPower; virtual double getRealPower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual CoreObject* find(std::string_view object) const override; virtual CoreObject* getSubObject(std::string_view typeName, index_t num) const override; virtual double getFreq(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset = nullptr) const override; virtual double getAngle(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset = nullptr) const override; protected: virtual double pSetControlUpdate(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode); + const SolverMode& sMode); virtual double vSetControlUpdate(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode); - virtual index_t pSetLocation(const solverMode& sMode); - virtual index_t vSetLocation(const solverMode& sMode); + const SolverMode& sMode); + virtual index_t pSetLocation(const SolverMode& sMode); + virtual index_t vSetLocation(const SolverMode& sMode); protected: class subModelInputs { @@ -206,10 +206,10 @@ class DynamicGenerator: public Generator { virtual void generateSubModelInputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode); + const SolverMode& sMode); virtual void generateSubModelInputLocs(const IOlocs& inputLocs, const stateData& stateDataValue, - const solverMode& sMode); + const SolverMode& sMode); GridSubModel* replaceModel(GridSubModel* newObject, GridSubModel* oldObject, index_t newIndex); diff --git a/src/griddyn/generators/Generator.cpp b/src/griddyn/generators/Generator.cpp index febccb330..447a9b702 100644 --- a/src/griddyn/generators/Generator.cpp +++ b/src/griddyn/generators/Generator.cpp @@ -146,7 +146,7 @@ void Generator::dynObjectInitializeA(coreTime time0, std::uint32_t flags) gridSecondary::dynObjectInitializeA(time0, flags); } -stateSizes Generator::localStateSizes(const solverMode& sMode) const +stateSizes Generator::localStateSizes(const SolverMode& sMode) const { stateSizes localStates; if (!isEnabled()) { @@ -160,7 +160,7 @@ stateSizes Generator::localStateSizes(const solverMode& sMode) const return localStates; } -count_t Generator::localJacobianCount(const solverMode& sMode) const +count_t Generator::localJacobianCount(const SolverMode& sMode) const { if (!isEnabled()) { return 0; @@ -208,7 +208,7 @@ void Generator::dynObjectInitializeB(const IOdata& /*inputs*/, void Generator::setState(coreTime time, const double state[], const double /*dstate_dt*/[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { Pset += dPdt * (time - prevTime); @@ -224,7 +224,7 @@ void Generator::setState(coreTime time, void Generator::guessState(coreTime /*time*/, double state[], double /*dstate_dt*/[], - const solverMode& sMode) + const SolverMode& sMode) { if ((!isDynamic(sMode)) && (stateSize(sMode) > 0)) { auto offset = offsets.getAlgOffset(sMode); @@ -349,7 +349,7 @@ double Generator::get(std::string_view param, unit unitType) const return ret; } -void Generator::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void Generator::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { if (Pset < -kHalfBigNum) { Pset = P; @@ -533,7 +533,7 @@ void Generator::setCapabilityCurve(const std::vector& ppts, void Generator::outputPartialDerivatives(const IOdata& /*inputs*/, const stateData& /*stateDataValue*/, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!isDynamic(sMode)) { // the bus is managing a remote bus voltage if (stateSize(sMode) > 0) { @@ -544,7 +544,7 @@ void Generator::outputPartialDerivatives(const IOdata& /*inputs*/, } } -count_t Generator::outputDependencyCount(index_t num, const solverMode& sMode) const +count_t Generator::outputDependencyCount(index_t num, const SolverMode& sMode) const { if (!isDynamic(sMode)) { // the bus is managing a remote bus voltage if (stateSize(sMode) > 0) { @@ -558,7 +558,7 @@ void Generator::ioPartialDerivatives(const IOdata& inputs, const stateData& /*stateDataValue*/, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (!isDynamic(sMode)) { if (inputs[voltageInLocation] < 0.8) { @@ -576,7 +576,7 @@ void Generator::ioPartialDerivatives(const IOdata& inputs, IOdata Generator::getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { IOdata output = {-P, -Q}; if (!isDynamic(sMode)) // use as a proxy for dynamic state @@ -603,7 +603,7 @@ IOdata Generator::getOutputs(const IOdata& inputs, double Generator::getRealPower(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& sMode) const + const SolverMode& sMode) const { double output = -P; if (!isDynamic(sMode)) // use as a proxy for dynamic state @@ -627,7 +627,7 @@ double Generator::getRealPower(const IOdata& inputs, } double Generator::getReactivePower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { double output = -Q; if (!isDynamic(sMode)) // use as a proxy for dynamic state @@ -658,7 +658,7 @@ double Generator::getReactivePower() const void Generator::algebraicUpdate(const IOdata& /*inputs*/, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { if ((!isDynamic(sMode)) && @@ -677,7 +677,7 @@ void Generator::algebraicUpdate(const IOdata& /*inputs*/, void Generator::residual(const IOdata& /*inputs*/, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if ((!isDynamic(sMode)) && (opFlags[indirect_voltage_control])) { // the bus is managing a remote bus voltage @@ -697,7 +697,7 @@ void Generator::jacobianElements(const IOdata& /*inputs*/, const stateData& /*stateDataValue*/, matrixData& matrixDataValue, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if ((!isDynamic(sMode)) && (opFlags[indirect_voltage_control])) { // the bus is managing a remote bus voltage @@ -714,7 +714,7 @@ void Generator::jacobianElements(const IOdata& /*inputs*/, } void Generator::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { const std::string prefix2 = prefix + getName(); @@ -758,7 +758,7 @@ double Generator::getAdjustableCapacityDown(coreTime time) const IOdata Generator::predictOutputs(coreTime predictionTime, const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { IOdata out(2); out[PoutLocation] = Pset; @@ -805,7 +805,7 @@ double Generator::getQmin(const coreTime /*time*/, double ptest) const } double Generator::getFreq(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset) const { *freqOffset = kNullLocation; @@ -813,7 +813,7 @@ double Generator::getFreq(const stateData& stateDataValue, } double Generator::getAngle(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset) const { *angleOffset = kNullLocation; diff --git a/src/griddyn/generators/IsocController.cpp b/src/griddyn/generators/IsocController.cpp index d37e8e9c3..ce71c1d55 100644 --- a/src/griddyn/generators/IsocController.cpp +++ b/src/griddyn/generators/IsocController.cpp @@ -91,7 +91,7 @@ void isocController::updateA(coreTime time) // printf("t=%f,output=%f\n", time, m_output); } -void isocController::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void isocController::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { prevTime = time; lastFreq = inputs[0]; diff --git a/src/griddyn/generators/IsocController.h b/src/griddyn/generators/IsocController.h index f6149558a..0011ad01c 100644 --- a/src/griddyn/generators/IsocController.h +++ b/src/griddyn/generators/IsocController.h @@ -36,7 +36,7 @@ class isocController: public GridSubModel { virtual void updateA(coreTime time) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void set(std::string_view param, std::string_view val) override; virtual void diff --git a/src/griddyn/generators/VariableGenerator.cpp b/src/griddyn/generators/VariableGenerator.cpp index 809afc475..4188055fb 100644 --- a/src/griddyn/generators/VariableGenerator.cpp +++ b/src/griddyn/generators/VariableGenerator.cpp @@ -123,7 +123,7 @@ void variableGenerator::set(std::string_view param, double val, unit unitType) void variableGenerator::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { DynamicGenerator::residual(inputs, sD, resid, sMode); if ((m_source != nullptr) && (m_source->isEnabled())) { @@ -138,7 +138,7 @@ void variableGenerator::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { DynamicGenerator::jacobianElements(inputs, sD, md, inputLocs, sMode); if ((m_source != nullptr) && (m_source->isEnabled())) { @@ -171,7 +171,7 @@ CoreObject* variableGenerator::getSubObject(std::string_view typeName, index_t n double variableGenerator::pSetControlUpdate(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) + const SolverMode& sMode) { if ((m_cBlock != nullptr) && (m_cBlock->isEnabled())) { return m_cBlock->getOutput(); @@ -179,7 +179,7 @@ double variableGenerator::pSetControlUpdate(const IOdata& inputs, return DynamicGenerator::pSetControlUpdate(inputs, sD, sMode); } -index_t variableGenerator::pSetLocation(const solverMode& sMode) +index_t variableGenerator::pSetLocation(const SolverMode& sMode) { if ((m_cBlock != nullptr) && (m_cBlock->isEnabled())) { return m_cBlock->getOutputLoc(sMode); diff --git a/src/griddyn/generators/VariableGenerator.h b/src/griddyn/generators/VariableGenerator.h index 5b3e1e13d..9e61c7764 100644 --- a/src/griddyn/generators/VariableGenerator.h +++ b/src/griddyn/generators/VariableGenerator.h @@ -50,13 +50,13 @@ class variableGenerator: public DynamicGenerator { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double getAdjustableCapacityUp(coreTime /*time*/ = maxTime) const override { @@ -73,8 +73,8 @@ class variableGenerator: public DynamicGenerator { protected: virtual double pSetControlUpdate(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; - virtual index_t pSetLocation(const solverMode& sMode) override; + const SolverMode& sMode) override; + virtual index_t pSetLocation(const SolverMode& sMode) override; }; } // namespace griddyn diff --git a/src/griddyn/genmodels/GenModel.cpp b/src/griddyn/genmodels/GenModel.cpp index 6ac794089..6996fe636 100644 --- a/src/griddyn/genmodels/GenModel.cpp +++ b/src/griddyn/genmodels/GenModel.cpp @@ -110,7 +110,7 @@ void GenModel::dynObjectInitializeB(const IOdata& inputs, // residual double GenModel::getFreq(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset) const { // there is no inertia in this gen model so it can't compute a frequency and @@ -122,7 +122,7 @@ double GenModel::getFreq(const stateData& stateDataValue, } double GenModel::getAngle(const stateData& /*stateDataValue*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t* angleOffset) const { // there is no inertia in this gen model so it can't compute a frequency and @@ -133,13 +133,13 @@ double GenModel::getAngle(const stateData& /*stateDataValue*/, return kNullVal; } -count_t GenModel::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t GenModel::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 0; } IOdata GenModel::getOutputs(const IOdata& inputs, const stateData& /*stateDataValue*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { IOdata out(2); const double voltage = inputs[voltageInLocation]; @@ -157,7 +157,7 @@ IOdata GenModel::getOutputs(const IOdata& inputs, double GenModel::getOutput(const IOdata& inputs, const stateData& /*stateDataValue*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t outNum) const { const double voltage = inputs[voltageInLocation]; @@ -189,7 +189,7 @@ void GenModel::ioPartialDerivatives(const IOdata& inputs, const stateData& /*stateDataValue*/, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { const double voltage = inputs[voltageInLocation]; diff --git a/src/griddyn/genmodels/GenModel3.cpp b/src/griddyn/genmodels/GenModel3.cpp index 1906e305d..0a3708a61 100644 --- a/src/griddyn/genmodels/GenModel3.cpp +++ b/src/griddyn/genmodels/GenModel3.cpp @@ -67,7 +67,7 @@ void GenModel3::dynObjectInitializeB(const IOdata& inputs, void GenModel3::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* gm = Loc.algStateLoc; @@ -93,7 +93,7 @@ void GenModel3::derivative(const IOdata& inputs, void GenModel3::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto Loc = offsets.getLocations(sD, update, sMode, this); @@ -106,7 +106,7 @@ void GenModel3::algebraicUpdate(const IOdata& inputs, void GenModel3::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -147,7 +147,7 @@ void GenModel3::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); diff --git a/src/griddyn/genmodels/GenModel3.h b/src/griddyn/genmodels/GenModel3.h index a452121cb..54e39c3b1 100644 --- a/src/griddyn/genmodels/GenModel3.h +++ b/src/griddyn/genmodels/GenModel3.h @@ -36,20 +36,20 @@ class GenModel3: public GenModelClassical { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; }; diff --git a/src/griddyn/genmodels/GenModel4.cpp b/src/griddyn/genmodels/GenModel4.cpp index ef8b08ac0..3df7d5940 100644 --- a/src/griddyn/genmodels/GenModel4.cpp +++ b/src/griddyn/genmodels/GenModel4.cpp @@ -60,7 +60,7 @@ void GenModel4::dynObjectInitializeB(const IOdata& inputs, void GenModel4::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); const double* gm = Loc.algStateLoc; @@ -100,7 +100,7 @@ void GenModel4::residual(const IOdata& inputs, // } } -void GenModel4::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void GenModel4::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { stateData sD(time, m_state.data()); derivative(inputs, sD, m_dstate_dt.data(), cLocalSolverMode); @@ -116,7 +116,7 @@ void GenModel4::timestep(coreTime time, const IOdata& inputs, const solverMode& void GenModel4::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto Loc = offsets.getLocations(sD, update, sMode, this); @@ -135,7 +135,7 @@ void GenModel4::algebraicUpdate(const IOdata& inputs, void GenModel4::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* ast = Loc.algStateLoc; @@ -162,7 +162,7 @@ void GenModel4::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); diff --git a/src/griddyn/genmodels/GenModel4.h b/src/griddyn/genmodels/GenModel4.h index 36655bb28..ac74913fc 100644 --- a/src/griddyn/genmodels/GenModel4.h +++ b/src/griddyn/genmodels/GenModel4.h @@ -31,25 +31,25 @@ class GenModel4: public GenModel3 { virtual stringVec localStateNames() const override; // dynamics - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; }; diff --git a/src/griddyn/genmodels/GenModel5.cpp b/src/griddyn/genmodels/GenModel5.cpp index e9e34e49f..fabf36f4f 100644 --- a/src/griddyn/genmodels/GenModel5.cpp +++ b/src/griddyn/genmodels/GenModel5.cpp @@ -66,7 +66,7 @@ void GenModel5::dynObjectInitializeB(const IOdata& inputs, void GenModel5::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto Loc = offsets.getLocations(sD, update, sMode, this); @@ -85,7 +85,7 @@ void GenModel5::algebraicUpdate(const IOdata& inputs, void GenModel5::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); const double* gm = Loc.algStateLoc; @@ -118,7 +118,7 @@ void GenModel5::residual(const IOdata& inputs, void GenModel5::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* ast = Loc.algStateLoc; @@ -150,7 +150,7 @@ void GenModel5::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { // md.assign (arrayIndex, RowIndex, ColIndex, value) const auto Loc = offsets.getLocations(sD, nullptr, sMode, this); diff --git a/src/griddyn/genmodels/GenModel5.h b/src/griddyn/genmodels/GenModel5.h index 5e7f15202..a323252be 100644 --- a/src/griddyn/genmodels/GenModel5.h +++ b/src/griddyn/genmodels/GenModel5.h @@ -36,20 +36,20 @@ class GenModel5: public GenModel4 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; }; diff --git a/src/griddyn/genmodels/GenModel5type2.cpp b/src/griddyn/genmodels/GenModel5type2.cpp index cfcbf44f6..54845dcdc 100644 --- a/src/griddyn/genmodels/GenModel5type2.cpp +++ b/src/griddyn/genmodels/GenModel5type2.cpp @@ -63,7 +63,7 @@ void GenModel5type2::dynObjectInitializeB(const IOdata& inputs, void GenModel5type2::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* gm = Loc.algStateLoc; @@ -93,7 +93,7 @@ void GenModel5type2::derivative(const IOdata& inputs, void GenModel5type2::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto Loc = offsets.getLocations(sD, update, sMode, this); @@ -112,7 +112,7 @@ void GenModel5type2::algebraicUpdate(const IOdata& inputs, void GenModel5type2::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -147,7 +147,7 @@ void GenModel5type2::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { // md.assign (arrayIndex, RowIndex, ColIndex, value) const auto Loc = offsets.getLocations(sD, sMode, this); diff --git a/src/griddyn/genmodels/GenModel5type2.h b/src/griddyn/genmodels/GenModel5type2.h index adafad6ff..e26b7ae8e 100644 --- a/src/griddyn/genmodels/GenModel5type2.h +++ b/src/griddyn/genmodels/GenModel5type2.h @@ -26,20 +26,20 @@ class GenModel5type2: public GenModel5 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; }; diff --git a/src/griddyn/genmodels/GenModel5type3.cpp b/src/griddyn/genmodels/GenModel5type3.cpp index c39552be4..6b5c082f4 100644 --- a/src/griddyn/genmodels/GenModel5type3.cpp +++ b/src/griddyn/genmodels/GenModel5type3.cpp @@ -58,7 +58,7 @@ void GenModel5type3::dynObjectInitializeB(const IOdata& inputs, void GenModel5type3::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* gm = Loc.algStateLoc; @@ -87,7 +87,7 @@ void GenModel5type3::derivative(const IOdata& inputs, void GenModel5type3::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -120,7 +120,7 @@ void GenModel5type3::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { // use the md.assign Macro defined in basicDefs // md.assign (arrayIndex, RowIndex, ColIndex, value) const diff --git a/src/griddyn/genmodels/GenModel5type3.h b/src/griddyn/genmodels/GenModel5type3.h index 73d50b15a..545126a68 100644 --- a/src/griddyn/genmodels/GenModel5type3.h +++ b/src/griddyn/genmodels/GenModel5type3.h @@ -26,16 +26,16 @@ class GenModel5type3: public GenModel3 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; }; } // namespace griddyn::genmodels diff --git a/src/griddyn/genmodels/GenModel6.cpp b/src/griddyn/genmodels/GenModel6.cpp index 1fd5d52e8..4cc07db71 100644 --- a/src/griddyn/genmodels/GenModel6.cpp +++ b/src/griddyn/genmodels/GenModel6.cpp @@ -79,7 +79,7 @@ void GenModel6::dynObjectInitializeB(const IOdata& inputs, void GenModel6::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto Loc = offsets.getLocations(sD, update, sMode, this); @@ -99,7 +99,7 @@ void GenModel6::algebraicUpdate(const IOdata& inputs, void GenModel6::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -141,7 +141,7 @@ void GenModel6::derivative(const IOdata& inputs, void GenModel6::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -175,7 +175,7 @@ void GenModel6::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); diff --git a/src/griddyn/genmodels/GenModel6.h b/src/griddyn/genmodels/GenModel6.h index ccc6ae44c..6407a7974 100644 --- a/src/griddyn/genmodels/GenModel6.h +++ b/src/griddyn/genmodels/GenModel6.h @@ -26,20 +26,20 @@ class GenModel6: public GenModel5 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; }; diff --git a/src/griddyn/genmodels/GenModel6type2.cpp b/src/griddyn/genmodels/GenModel6type2.cpp index fce42ca98..f3bf173d9 100644 --- a/src/griddyn/genmodels/GenModel6type2.cpp +++ b/src/griddyn/genmodels/GenModel6type2.cpp @@ -67,7 +67,7 @@ void GenModel6type2::dynObjectInitializeB(const IOdata& inputs, void GenModel6type2::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto Loc = offsets.getLocations(sD, update, sMode, this); @@ -86,7 +86,7 @@ void GenModel6type2::algebraicUpdate(const IOdata& inputs, void GenModel6type2::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* gm = Loc.algStateLoc; @@ -121,7 +121,7 @@ void GenModel6type2::derivative(const IOdata& inputs, void GenModel6type2::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -156,7 +156,7 @@ void GenModel6type2::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); diff --git a/src/griddyn/genmodels/GenModel6type2.h b/src/griddyn/genmodels/GenModel6type2.h index 13b780f74..17f982c0a 100644 --- a/src/griddyn/genmodels/GenModel6type2.h +++ b/src/griddyn/genmodels/GenModel6type2.h @@ -26,20 +26,20 @@ class GenModel6type2: public GenModel5type2 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; }; diff --git a/src/griddyn/genmodels/GenModel8.cpp b/src/griddyn/genmodels/GenModel8.cpp index 6584951b0..be3fd18ca 100644 --- a/src/griddyn/genmodels/GenModel8.cpp +++ b/src/griddyn/genmodels/GenModel8.cpp @@ -65,7 +65,7 @@ void GenModel8::dynObjectInitializeB(const IOdata& inputs, void GenModel8::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -106,7 +106,7 @@ void GenModel8::derivative(const IOdata& inputs, void GenModel8::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -141,7 +141,7 @@ void GenModel8::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { // md.assign (arrayIndex, RowIndex, ColIndex, value) const auto Loc = offsets.getLocations(sD, nullptr, sMode, this); diff --git a/src/griddyn/genmodels/GenModel8.h b/src/griddyn/genmodels/GenModel8.h index 183850eae..be885d819 100644 --- a/src/griddyn/genmodels/GenModel8.h +++ b/src/griddyn/genmodels/GenModel8.h @@ -26,16 +26,16 @@ class GenModel8: public GenModel6 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; }; } // namespace griddyn::genmodels diff --git a/src/griddyn/genmodels/GenModelClassical.cpp b/src/griddyn/genmodels/GenModelClassical.cpp index 1f48be8f8..11a9a39a1 100644 --- a/src/griddyn/genmodels/GenModelClassical.cpp +++ b/src/griddyn/genmodels/GenModelClassical.cpp @@ -87,7 +87,7 @@ void GenModelClassical::computeInitialAngleAndCurrent(const IOdata& inputs, void GenModelClassical::updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) + const SolverMode& sMode) { if (sD.updateRequired(seqId)) { auto Loc = offsets.getLocations(sD, sMode, this); @@ -102,7 +102,7 @@ void GenModelClassical::updateLocalCache(const IOdata& inputs, void GenModelClassical::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto Loc = offsets.getLocations(sD, update, sMode, this); @@ -123,7 +123,7 @@ void GenModelClassical::algebraicUpdate(const IOdata& inputs, void GenModelClassical::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -178,7 +178,7 @@ rvd[1] = 0.5 * (Pmt - Pe - D * (gmd[1] - 1.0)) / H - gmp[1]; void GenModelClassical::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); double* dv = Loc.destDiffLoc; @@ -199,7 +199,7 @@ void GenModelClassical::derivative(const IOdata& inputs, } double GenModelClassical::getFreq(const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset) const { double omega{1.0}; @@ -232,7 +232,7 @@ double GenModelClassical::getFreq(const stateData& sD, } double GenModelClassical::getAngle(const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset) const { double angle = kNullVal; @@ -266,7 +266,7 @@ double GenModelClassical::getAngle(const stateData& sD, IOdata GenModelClassical::getOutputs(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { auto Loc = offsets.getLocations(sD, sMode, this); IOdata out(2); @@ -277,7 +277,7 @@ IOdata GenModelClassical::getOutputs(const IOdata& /*inputs*/, double GenModelClassical::getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t numOut) const { auto Loc = offsets.getLocations(sD, sMode, this); @@ -303,7 +303,7 @@ void GenModelClassical::ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); @@ -326,7 +326,7 @@ void GenModelClassical::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); @@ -401,7 +401,7 @@ rv[1] = Vq + Rs*gm[1] - (Xdp - Xl)*gm[0]; void GenModelClassical::outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); auto refAlg = Loc.algOffset; @@ -426,7 +426,7 @@ void GenModelClassical::outputPartialDerivatives(const IOdata& inputs, } } -count_t GenModelClassical::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t GenModelClassical::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 3; } diff --git a/src/griddyn/genmodels/GenModelClassical.h b/src/griddyn/genmodels/GenModelClassical.h index 466c3af74..d64072520 100644 --- a/src/griddyn/genmodels/GenModelClassical.h +++ b/src/griddyn/genmodels/GenModelClassical.h @@ -42,54 +42,54 @@ class GenModelClassical: public GenModel { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; using GenModel::getOutput; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t numOut = 0) const override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; + const SolverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; /** helper function to get omega and its state location */ virtual double getFreq(const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset = nullptr) const override; virtual double getAngle(const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset = nullptr) const override; virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; protected: void computeInitialAngleAndCurrent(const IOdata& inputs, diff --git a/src/griddyn/genmodels/GenModelGENROU.cpp b/src/griddyn/genmodels/GenModelGENROU.cpp index 03bcf09b4..36788c470 100644 --- a/src/griddyn/genmodels/GenModelGENROU.cpp +++ b/src/griddyn/genmodels/GenModelGENROU.cpp @@ -80,7 +80,7 @@ void GenModelGENROU::dynObjectInitializeB(const IOdata& inputs, void GenModelGENROU::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto Loc = offsets.getLocations(sD, update, sMode, this); @@ -99,7 +99,7 @@ void GenModelGENROU::algebraicUpdate(const IOdata& inputs, void GenModelGENROU::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); @@ -161,7 +161,7 @@ void GenModelGENROU::derivative(const IOdata& inputs, void GenModelGENROU::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -199,7 +199,7 @@ void GenModelGENROU::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); diff --git a/src/griddyn/genmodels/GenModelGENROU.h b/src/griddyn/genmodels/GenModelGENROU.h index 3255a7d74..41c547d83 100644 --- a/src/griddyn/genmodels/GenModelGENROU.h +++ b/src/griddyn/genmodels/GenModelGENROU.h @@ -25,20 +25,20 @@ class GenModelGENROU: public GenModel5 { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; }; diff --git a/src/griddyn/genmodels/GenModelInverter.cpp b/src/griddyn/genmodels/GenModelInverter.cpp index 5fe90df9f..a91c29883 100644 --- a/src/griddyn/genmodels/GenModelInverter.cpp +++ b/src/griddyn/genmodels/GenModelInverter.cpp @@ -72,7 +72,7 @@ void GenModelInverter::dynObjectInitializeB(const IOdata& inputs, void GenModelInverter::algebraicUpdate(const IOdata& inputs, const stateData& /*stateDataValue*/, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { auto offset = offsets.getAlgOffset(sMode); @@ -118,7 +118,7 @@ void GenModelInverter::algebraicUpdate(const IOdata& inputs, void GenModelInverter::residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (!hasAlgebraic(sMode)) { return; @@ -155,7 +155,7 @@ void GenModelInverter::residual(const IOdata& inputs, } double GenModelInverter::getFreq(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset) const { // there is no inertia in this gen model so it can't compute a frequency and @@ -167,7 +167,7 @@ double GenModelInverter::getFreq(const stateData& stateDataValue, } double GenModelInverter::getAngle(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset) const { auto offset = offsets.getAlgOffset(sMode); @@ -180,7 +180,7 @@ double GenModelInverter::getAngle(const stateData& stateDataValue, IOdata GenModelInverter::getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { auto Loc = offsets.getLocations(stateDataValue, sMode, this); @@ -216,7 +216,7 @@ double GenModelInverter::reactivePowerCompute(double voltage, double GenModelInverter::getOutput(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outNum) const { auto Loc = offsets.getLocations(stateDataValue, sMode, this); @@ -238,7 +238,7 @@ void GenModelInverter::ioPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(stateDataValue, sMode, this); @@ -276,7 +276,7 @@ void GenModelInverter::jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (!hasAlgebraic(sMode)) { return; @@ -316,7 +316,7 @@ void GenModelInverter::jacobianElements(const IOdata& inputs, void GenModelInverter::outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!hasAlgebraic(sMode)) { return; @@ -341,7 +341,7 @@ void GenModelInverter::outputPartialDerivatives(const IOdata& inputs, (voltage * exciterField * g * cosineAngle)); } -count_t GenModelInverter::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t GenModelInverter::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 1; } @@ -400,7 +400,7 @@ void GenModelInverter::reCalcImpedences() void GenModelInverter::rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { if (rootSize(sMode) > 0) { auto rootOffset = offsets.getRootOffset(sMode); @@ -429,7 +429,7 @@ void GenModelInverter::rootTest(const IOdata& inputs, void GenModelInverter::rootTrigger(coreTime /*time*/, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { if (rootSize(sMode) > 0) { auto rootOffset = offsets.getRootOffset(sMode); @@ -453,7 +453,7 @@ void GenModelInverter::rootTrigger(coreTime /*time*/, ChangeCode GenModelInverter::rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel /*level*/) { if (rootSize(sMode) > 0) { diff --git a/src/griddyn/genmodels/GenModelInverter.h b/src/griddyn/genmodels/GenModelInverter.h index a8f257412..7f6100595 100644 --- a/src/griddyn/genmodels/GenModelInverter.h +++ b/src/griddyn/genmodels/GenModelInverter.h @@ -40,58 +40,58 @@ class GenModelInverter: public GenModel { virtual void residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; using GenModel::getOutput; virtual double getOutput(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t outNum = 0) const override; virtual void jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; /** helper function to get omega and its state location */ virtual double getFreq(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* freqOffset = nullptr) const override; virtual double getAngle(const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, index_t* angleOffset = nullptr) const override; virtual void rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; private: diff --git a/src/griddyn/governors/Governor.cpp b/src/griddyn/governors/Governor.cpp index 2027a37f6..f55d0e112 100644 --- a/src/griddyn/governors/Governor.cpp +++ b/src/griddyn/governors/Governor.cpp @@ -137,7 +137,7 @@ void Governor::dynObjectInitializeB(const IOdata& inputs, void Governor::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { cb.blockResidual(inputs[govOmegaInLocation], 0, sD, resid, sMode); dbb.blockResidual(cb.getBlockOutput(sD, sMode), 0, sD, resid, sMode); @@ -145,7 +145,7 @@ void Governor::residual(const IOdata& inputs, dbb.getBlockOutput(sD, sMode) + inputs[govpSetInLocation], 0, sD, resid, sMode); } -void Governor::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void Governor::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { double out = cb.step(time, inputs[govOmegaInLocation]); @@ -156,7 +156,7 @@ void Governor::timestep(coreTime time, const IOdata& inputs, const solverMode& / void Governor::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { IOdata i{inputs[govOmegaInLocation]}; // deadband doesn't have any derivatives cb.derivative(i, sD, deriv, sMode); @@ -168,7 +168,7 @@ void Governor::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { cb.blockJacobianElements( inputs[govOmegaInLocation], 0, sD, md, inputLocs[govOmegaInLocation], sMode); @@ -233,7 +233,7 @@ void Governor::jacobianElements(const IOdata& inputs, void Governor::rootTest(const IOdata& /*inputs*/, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { IOdata i{cb.getOutput(kNullVec, sD, sMode)}; if (dbb.checkFlag(has_roots)) { @@ -245,7 +245,7 @@ void Governor::rootTest(const IOdata& /*inputs*/, } } -index_t Governor::findIndex(std::string_view field, const solverMode& sMode) const +index_t Governor::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if (field == "pm") { diff --git a/src/griddyn/governors/GovernorHydro.cpp b/src/griddyn/governors/GovernorHydro.cpp index 174b77357..639392aac 100644 --- a/src/griddyn/governors/GovernorHydro.cpp +++ b/src/griddyn/governors/GovernorHydro.cpp @@ -68,7 +68,7 @@ void GovernorHydro::dynObjectInitializeB(const IOdata& /*inputs*/, void GovernorHydro::residual(const IOdata& /*inputs*/, const stateData& /*sD*/, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); resid[offset] = 0; @@ -79,7 +79,7 @@ void GovernorHydro::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -104,7 +104,7 @@ void GovernorHydro::jacobianElements(const IOdata& /*inputs*/, md.assign(refI + 1, refI + 1, -1 / T1 - sD.cj); } -index_t GovernorHydro::findIndex(std::string_view field, const solverMode& /*sMode*/) const +index_t GovernorHydro::findIndex(std::string_view field, const SolverMode& /*sMode*/) const { index_t ret = kInvalidLocation; if (field == "pm") { diff --git a/src/griddyn/governors/GovernorHydro.h b/src/griddyn/governors/GovernorHydro.h index e99fed0c9..93ec49a1c 100644 --- a/src/griddyn/governors/GovernorHydro.h +++ b/src/griddyn/governors/GovernorHydro.h @@ -26,19 +26,19 @@ class GovernorHydro: public GovernorIeeeSimple { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; }; } // namespace griddyn::governors diff --git a/src/griddyn/governors/GovernorIeeeSimple.cpp b/src/griddyn/governors/GovernorIeeeSimple.cpp index 4f0c0e1d3..a7ce55fdd 100644 --- a/src/griddyn/governors/GovernorIeeeSimple.cpp +++ b/src/griddyn/governors/GovernorIeeeSimple.cpp @@ -74,7 +74,7 @@ void GovernorIeeeSimple::dynObjectInitializeB(const IOdata& /*inputs*/, void GovernorIeeeSimple::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -89,7 +89,7 @@ void GovernorIeeeSimple::residual(const IOdata& inputs, void GovernorIeeeSimple::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); @@ -106,7 +106,7 @@ void GovernorIeeeSimple::derivative(const IOdata& inputs, Loc.destDiffLoc[1] = (-gs[1] + (1 - T2 / T1) * (omega - 1.0)) / T1; } -void GovernorIeeeSimple::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void GovernorIeeeSimple::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { GovernorIeeeSimple::derivative(inputs, emptyStateData, m_dstate_dt.data(), cLocalSolverMode); double dt = time - prevTime; @@ -128,7 +128,7 @@ void GovernorIeeeSimple::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -169,7 +169,7 @@ if (opFlags.test (uses_deadband)) md.assign(refI + 1, refI + 1, -1 / T1 - sD.cj); } -index_t GovernorIeeeSimple::findIndex(std::string_view field, const solverMode& sMode) const +index_t GovernorIeeeSimple::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if (field == "pm") { @@ -184,7 +184,7 @@ index_t GovernorIeeeSimple::findIndex(std::string_view field, const solverMode& void GovernorIeeeSimple::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { int rootOffset = offsets.getRootOffset(sMode); /*if (opFlags.test (uses_deadband)) @@ -217,7 +217,7 @@ void GovernorIeeeSimple::rootTest(const IOdata& inputs, void GovernorIeeeSimple::rootTrigger(coreTime /*time*/, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { int rootOffset = offsets.getRootOffset(sMode); /*if (opFlags.test (uses_deadband)) diff --git a/src/griddyn/governors/GovernorIeeeSimple.h b/src/griddyn/governors/GovernorIeeeSimple.h index 5ce6c3b66..f416271e0 100644 --- a/src/griddyn/governors/GovernorIeeeSimple.h +++ b/src/griddyn/governors/GovernorIeeeSimple.h @@ -32,29 +32,29 @@ class GovernorIeeeSimple: public Governor { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + const SolverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; // virtual void setTime(coreTime time){prevTime=time;}; }; diff --git a/src/griddyn/governors/GovernorReheat.cpp b/src/griddyn/governors/GovernorReheat.cpp index 2d4281dab..8f57767de 100644 --- a/src/griddyn/governors/GovernorReheat.cpp +++ b/src/griddyn/governors/GovernorReheat.cpp @@ -77,12 +77,12 @@ void GovernorReheat::dynObjectInitializeB(const IOdata& inputs, void GovernorReheat::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); const double* gsp = sD.dstate_dt + offset; if (isAlgebraicOnly(sMode)) { - gsp = sD.dstate_dt + offsets.getAlgOffset(solverMode(4)); + gsp = sD.dstate_dt + offsets.getAlgOffset(SolverMode(4)); resid[offset + 0] = gsp[1] + T4 / T5 * (gsp[2] + T3 / T2 * gsp[3]) - sD.state[offset]; return; } @@ -106,7 +106,7 @@ void GovernorReheat::residual(const IOdata& inputs, void GovernorReheat::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); const double* gs = sD.state + offset; @@ -127,7 +127,7 @@ void GovernorReheat::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); if (isAlgebraicOnly(sMode)) { @@ -185,7 +185,7 @@ void GovernorReheat::jacobianElements(const IOdata& inputs, md.assign(refI, refI + 3, T4 / T5 * (T3 / T2)); } -index_t GovernorReheat::findIndex(std::string_view field, const solverMode& /*sMode*/) const +index_t GovernorReheat::findIndex(std::string_view field, const SolverMode& /*sMode*/) const { index_t ret = kInvalidLocation; if (field == "pm") { diff --git a/src/griddyn/governors/GovernorReheat.h b/src/griddyn/governors/GovernorReheat.h index cf821f541..9fc01e7ee 100644 --- a/src/griddyn/governors/GovernorReheat.h +++ b/src/griddyn/governors/GovernorReheat.h @@ -26,20 +26,20 @@ class GovernorReheat: public Governor { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; // virtual void setTime (coreTime time) const{prevTime=time;}; }; diff --git a/src/griddyn/governors/GovernorSteamNR.cpp b/src/griddyn/governors/GovernorSteamNR.cpp index 4a1da4b55..2bbc2a7f9 100644 --- a/src/griddyn/governors/GovernorSteamNR.cpp +++ b/src/griddyn/governors/GovernorSteamNR.cpp @@ -72,7 +72,7 @@ void GovernorSteamNR::dynObjectInitializeB(const IOdata& /*inputs*/, void GovernorSteamNR::residual(const IOdata& /*inputs*/, const stateData& /*sD*/, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); resid[offset] = 0; @@ -83,7 +83,7 @@ void GovernorSteamNR::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -108,7 +108,7 @@ void GovernorSteamNR::jacobianElements(const IOdata& /*inputs*/, md.assign(refI + 1, refI + 1, -1 / T1 - sD.cj); } -index_t GovernorSteamNR::findIndex(std::string_view field, const solverMode& /*sMode*/) const +index_t GovernorSteamNR::findIndex(std::string_view field, const SolverMode& /*sMode*/) const { index_t ret = kInvalidLocation; if (field == "pm") { diff --git a/src/griddyn/governors/GovernorSteamNR.h b/src/griddyn/governors/GovernorSteamNR.h index ca4b4d605..17245607b 100644 --- a/src/griddyn/governors/GovernorSteamNR.h +++ b/src/griddyn/governors/GovernorSteamNR.h @@ -25,18 +25,18 @@ class GovernorSteamNR: public GovernorIeeeSimple { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // only called if the genModel is not present virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; }; } // namespace griddyn::governors diff --git a/src/griddyn/governors/GovernorSteamTCSR.cpp b/src/griddyn/governors/GovernorSteamTCSR.cpp index 20cffb9c7..ee01ffcc2 100644 --- a/src/griddyn/governors/GovernorSteamTCSR.cpp +++ b/src/griddyn/governors/GovernorSteamTCSR.cpp @@ -69,7 +69,7 @@ void GovernorSteamTCSR::dynObjectInitializeB(const IOdata& inputs, void GovernorSteamTCSR::residual(const IOdata& /*inputs*/, const stateData& /*sD*/, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); resid[offset] = 0; @@ -80,7 +80,7 @@ void GovernorSteamTCSR::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -106,7 +106,7 @@ void GovernorSteamTCSR::jacobianElements(const IOdata& /*inputs*/, md.assign(refI + 1, refI + 1, -1 / T1 - sD.cj); } -index_t GovernorSteamTCSR::findIndex(std::string_view field, const solverMode& /*sMode*/) const +index_t GovernorSteamTCSR::findIndex(std::string_view field, const SolverMode& /*sMode*/) const { index_t ret = kInvalidLocation; if (field == "pm") { diff --git a/src/griddyn/governors/GovernorSteamTCSR.h b/src/griddyn/governors/GovernorSteamTCSR.h index a7f2caee3..43d13fc3c 100644 --- a/src/griddyn/governors/GovernorSteamTCSR.h +++ b/src/griddyn/governors/GovernorSteamTCSR.h @@ -30,18 +30,18 @@ class GovernorSteamTCSR: public GovernorSteamNR { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; }; } // namespace griddyn::governors diff --git a/src/griddyn/governors/GovernorTgov1.cpp b/src/griddyn/governors/GovernorTgov1.cpp index 6e7a1b5c4..b9c1dea34 100644 --- a/src/griddyn/governors/GovernorTgov1.cpp +++ b/src/griddyn/governors/GovernorTgov1.cpp @@ -61,7 +61,7 @@ void GovernorTgov1::dynObjectInitializeB(const IOdata& /*inputs*/, void GovernorTgov1::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { // double omega = getControlFrequency (inputs); double omega = inputs[govOmegaInLocation]; @@ -81,7 +81,7 @@ void GovernorTgov1::residual(const IOdata& inputs, void GovernorTgov1::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); @@ -99,7 +99,7 @@ void GovernorTgov1::derivative(const IOdata& inputs, Loc.destDiffLoc[0] = (Loc.diffStateLoc[1] - Loc.diffStateLoc[0] - T2 * Loc.destDiffLoc[1]) / T3; } -void GovernorTgov1::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void GovernorTgov1::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { GovernorTgov1::derivative(inputs, emptyStateData, m_dstate_dt.data(), cLocalSolverMode); double dt = time - prevTime; @@ -116,7 +116,7 @@ void GovernorTgov1::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, nullptr, sMode, this); @@ -175,7 +175,7 @@ if (opFlags.test (uses_deadband)) void GovernorTgov1::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { int rootOffset = offsets.getRootOffset(sMode); /* if (opFlags.test (uses_deadband)) @@ -205,7 +205,7 @@ void GovernorTgov1::rootTest(const IOdata& inputs, void GovernorTgov1::rootTrigger(coreTime /*time*/, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { int rootOffset = offsets.getRootOffset(sMode); /*if (opFlags.test (uses_deadband)) @@ -239,7 +239,7 @@ void GovernorTgov1::rootTrigger(coreTime /*time*/, } } -index_t GovernorTgov1::findIndex(std::string_view field, const solverMode& sMode) const +index_t GovernorTgov1::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if ((field == "pm") || (field == "pmech")) { diff --git a/src/griddyn/governors/GovernorTgov1.h b/src/griddyn/governors/GovernorTgov1.h index 8064bc759..e1554592b 100644 --- a/src/griddyn/governors/GovernorTgov1.h +++ b/src/griddyn/governors/GovernorTgov1.h @@ -26,29 +26,29 @@ class GovernorTgov1: public GovernorIeeeSimple { virtual void set(std::string_view param, std::string_view val) override; virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + const SolverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; }; } // namespace griddyn::governors diff --git a/src/griddyn/links/AcLine.cpp b/src/griddyn/links/AcLine.cpp index 60a594c1f..fbf00a0ab 100644 --- a/src/griddyn/links/AcLine.cpp +++ b/src/griddyn/links/AcLine.cpp @@ -139,7 +139,7 @@ double AcLine::quickupdateP() return linkFlows.P1; } -void AcLine::timestep(const coreTime time, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void AcLine::timestep(const coreTime time, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { if (!isEnabled()) { return; @@ -577,7 +577,7 @@ void AcLine::ioPartialDerivatives(id_type_t busId, const stateData& /*sD*/, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { // check if line is enabled @@ -625,7 +625,7 @@ void AcLine::ioPartialDerivatives(id_type_t busId, void AcLine::outputPartialDerivatives(const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /*md*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { // there are theoretically 4 outputs for a standard ac line, but no internal states therefore // if this function is called from an external entity there are no output partial derivatives @@ -634,7 +634,7 @@ void AcLine::outputPartialDerivatives(const IOdata& /*inputs*/, void AcLine::outputPartialDerivatives(id_type_t busId, const stateData& /*sD*/, matrixData& md, - const solverMode& sMode) + const SolverMode& sMode) { if (!isConnected()) { // if there is no connection there is no coupling return; @@ -687,7 +687,7 @@ void AcLine::outputPartialDerivatives(id_type_t busId, } } -count_t AcLine::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t AcLine::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 2; } @@ -730,12 +730,12 @@ double AcLine::getMaxTransfer() const void AcLine::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { prevTime = time; stateData sD(time, state, dstate_dt); - if (sMode.approx[decoupled]) { // recompute power with new state updates for the decoupled + if (sMode.approx[DECOUPLED]) { // recompute power with new state updates for the decoupled // system updateLocalCache(noInputs, sD, sMode); constLinkInfo = linkInfo; // update the constant linkInfo @@ -743,7 +743,7 @@ void AcLine::setState(coreTime time, linkInfo.seqID = 0; // update the cache twice to get the correct values with the decoupled mode updateLocalCache(noInputs, sD, sMode); - } else if (sMode.approx[linear]) { + } else if (sMode.approx[LINEAR]) { // reLinearize at each step loadLinkInfo(sD, sMode); if (!isConnected()) { @@ -769,7 +769,7 @@ void AcLine::setState(coreTime time, constLinkFlows = linkFlows; // update the constant linkFlows } -double AcLine::getAngle(const double state[], const solverMode& sMode) const +double AcLine::getAngle(const double state[], const SolverMode& sMode) const { double t1 = B1->getAngle(state, sMode); double t2 = B2->getAngle(state, sMode); @@ -790,7 +790,7 @@ ChangeCode ChangeCode AcLine::rootCheck(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { auto ret = ChangeCode::NO_CHANGE; @@ -806,7 +806,7 @@ ChangeCode AcLine::rootCheck(const IOdata& /*inputs*/, } void AcLine::updateLocalCache(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode) + const SolverMode& sMode) { if (!isEnabled()) { return; @@ -924,7 +924,7 @@ void AcLine::loadLinkInfo() constLinkComp = linkComp; } -void AcLine::loadLinkInfo(const stateData& sD, const solverMode& sMode) +void AcLine::loadLinkInfo(const stateData& sD, const SolverMode& sMode) { if ((linkInfo.seqID == sD.seqID) && (sD.seqID != 0)) { return; @@ -1609,25 +1609,25 @@ void AcLine::swOpenDeriv() void AcLine::loadApproxFunctions() { // load up the member function pointer array to point to the correct function - flowCalc[indexVal(ApproxKeyMask::none)] = &AcLine::fullCalc; - flowCalc[indexVal(ApproxKeyMask::decoupled)] = &AcLine::decoupledCalc; - flowCalc[indexVal(ApproxKeyMask::sm_angle)] = &AcLine::smallAngleCalc; - flowCalc[indexVal(ApproxKeyMask::sm_angle_decoupled)] = &AcLine::smallAngleDecoupledCalc; - flowCalc[indexVal(ApproxKeyMask::simplified)] = &AcLine::simplifiedCalc; - flowCalc[indexVal(ApproxKeyMask::simplified_decoupled)] = &AcLine::simplifiedDecoupledCalc; - flowCalc[indexVal(ApproxKeyMask::simplified_sm_angle)] = &AcLine::smallAngleSimplifiedCalc; - flowCalc[indexVal(ApproxKeyMask::fast_decoupled)] = &AcLine::fastDecoupledCalc; - flowCalc[indexVal(ApproxKeyMask::linear)] = &AcLine::linearCalc; - - derivCalc[indexVal(ApproxKeyMask::none)] = &AcLine::fullDeriv; - derivCalc[indexVal(ApproxKeyMask::decoupled)] = &AcLine::decoupledDeriv; - derivCalc[indexVal(ApproxKeyMask::sm_angle)] = &AcLine::smallAngleDeriv; - derivCalc[indexVal(ApproxKeyMask::sm_angle_decoupled)] = &AcLine::smallAngleDecoupledDeriv; - derivCalc[indexVal(ApproxKeyMask::simplified)] = &AcLine::simplifiedDeriv; - derivCalc[indexVal(ApproxKeyMask::simplified_decoupled)] = &AcLine::simplifiedDecoupledDeriv; - derivCalc[indexVal(ApproxKeyMask::simplified_sm_angle)] = &AcLine::smallAngleSimplifiedDeriv; - derivCalc[indexVal(ApproxKeyMask::fast_decoupled)] = &AcLine::fastDecoupledDeriv; - derivCalc[indexVal(ApproxKeyMask::linear)] = &AcLine::linearDeriv; + flowCalc[indexVal(ApproxKeyMask::NONE)] = &AcLine::fullCalc; + flowCalc[indexVal(ApproxKeyMask::DECOUPLED)] = &AcLine::decoupledCalc; + flowCalc[indexVal(ApproxKeyMask::SM_ANGLE)] = &AcLine::smallAngleCalc; + flowCalc[indexVal(ApproxKeyMask::SM_ANGLE_DECOUPLED)] = &AcLine::smallAngleDecoupledCalc; + flowCalc[indexVal(ApproxKeyMask::SIMPLIFIED)] = &AcLine::simplifiedCalc; + flowCalc[indexVal(ApproxKeyMask::SIMPLIFIED_DECOUPLED)] = &AcLine::simplifiedDecoupledCalc; + flowCalc[indexVal(ApproxKeyMask::SIMPLIFIED_SM_ANGLE)] = &AcLine::smallAngleSimplifiedCalc; + flowCalc[indexVal(ApproxKeyMask::FAST_DECOUPLED)] = &AcLine::fastDecoupledCalc; + flowCalc[indexVal(ApproxKeyMask::LINEAR)] = &AcLine::linearCalc; + + derivCalc[indexVal(ApproxKeyMask::NONE)] = &AcLine::fullDeriv; + derivCalc[indexVal(ApproxKeyMask::DECOUPLED)] = &AcLine::decoupledDeriv; + derivCalc[indexVal(ApproxKeyMask::SM_ANGLE)] = &AcLine::smallAngleDeriv; + derivCalc[indexVal(ApproxKeyMask::SM_ANGLE_DECOUPLED)] = &AcLine::smallAngleDecoupledDeriv; + derivCalc[indexVal(ApproxKeyMask::SIMPLIFIED)] = &AcLine::simplifiedDeriv; + derivCalc[indexVal(ApproxKeyMask::SIMPLIFIED_DECOUPLED)] = &AcLine::simplifiedDecoupledDeriv; + derivCalc[indexVal(ApproxKeyMask::SIMPLIFIED_SM_ANGLE)] = &AcLine::smallAngleSimplifiedDeriv; + derivCalc[indexVal(ApproxKeyMask::FAST_DECOUPLED)] = &AcLine::fastDecoupledDeriv; + derivCalc[indexVal(ApproxKeyMask::LINEAR)] = &AcLine::linearDeriv; } // NOLINTEND(bugprone-branch-clone,misc-const-correctness,readability-else-after-return,readability-identifier-length,readability-math-missing-parentheses) diff --git a/src/griddyn/links/AcLine.h b/src/griddyn/links/AcLine.h index c1c4a96de..55a401ba9 100644 --- a/src/griddyn/links/AcLine.h +++ b/src/griddyn/links/AcLine.h @@ -153,16 +153,16 @@ class AcLine: public Link { virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; /** @brief do a quick update (may be deprecated) * @return the power transfer */ virtual double quickupdateP() override; using Link::getAngle; - virtual double getAngle(const double state[], const solverMode& sMode) const override; + virtual double getAngle(const double state[], const SolverMode& sMode) const override; virtual void getParameterStrings(stringVec& pstr, ParamStringType pstype) const override; virtual double get(std::string_view param, @@ -181,28 +181,28 @@ class AcLine: public Link { const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(id_type_t busId, const stateData& sD, matrixData& md, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual double getMaxTransfer() const override; // virtual void busResidual(index_t busId, const stateData &sD, double *Fp, double *Fq, const - // solverMode &sMode); + // SolverMode &sMode); virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; virtual bool testAndTrip(int tripLevel) override; @@ -282,7 +282,7 @@ class AcLine: public Link { /** @brief load information into the linkInfo structure @param[in] sD the state Data @param[in] sMode the corresponding solver Mode*/ - void loadLinkInfo(const stateData& sD, const solverMode& sMode); + void loadLinkInfo(const stateData& sD, const SolverMode& sMode); /** @brief load the approximation functions in the bizarrely defined array above*/ void loadApproxFunctions(); diff --git a/src/griddyn/links/AcdcConverter.cpp b/src/griddyn/links/AcdcConverter.cpp index 73f3e13dd..38780af79 100644 --- a/src/griddyn/links/AcdcConverter.cpp +++ b/src/griddyn/links/AcdcConverter.cpp @@ -110,7 +110,7 @@ CoreObject* acdcConverter::clone(CoreObject* obj) const return nobj; } -void acdcConverter::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void acdcConverter::timestep(coreTime time, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { // TODO(phlpt): This function is incorrect. if (!isEnabled()) { @@ -301,7 +301,7 @@ void acdcConverter::ioPartialDerivatives(id_type_t busId, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (!(isEnabled())) { return; @@ -365,7 +365,7 @@ linkInfo.Q1 = -std::sqrt(sr*sr - linkInfo.P1*linkInfo.P1); void acdcConverter::outputPartialDerivatives(const IOdata& /*inputs*/, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!(isEnabled())) { return; @@ -388,7 +388,7 @@ void acdcConverter::outputPartialDerivatives(const IOdata& /*inputs*/, void acdcConverter::outputPartialDerivatives(id_type_t busId, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!(isEnabled())) { return; @@ -463,7 +463,7 @@ void acdcConverter::outputPartialDerivatives(id_type_t busId, } } -count_t acdcConverter::outputDependencyCount(index_t /*num*/, const solverMode& sMode) const +count_t acdcConverter::outputDependencyCount(index_t /*num*/, const SolverMode& sMode) const { return (isDynamic(sMode)) ? 2 : 1; } @@ -472,7 +472,7 @@ void acdcConverter::jacobianElements(const IOdata& /*inputs*/, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { auto bus1Locs = B1->getOutputLocs(sMode); auto bus1VoltageOffset = bus1Locs[voltageInLocation]; @@ -566,7 +566,7 @@ void acdcConverter::jacobianElements(const IOdata& /*inputs*/, void acdcConverter::residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(inputs, stateDataValue, sMode); if (isDynamic(sMode)) { @@ -607,7 +607,7 @@ void acdcConverter::residual(const IOdata& inputs, void acdcConverter::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { Idc = state[offsets.getAlgOffset(sMode)]; @@ -633,7 +633,7 @@ void acdcConverter::setState(coreTime time, void acdcConverter::guessState(coreTime time, double state[], double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { state[offsets.getAlgOffset(sMode)] = Idc; @@ -649,7 +649,7 @@ void acdcConverter::guessState(coreTime time, void acdcConverter::updateLocalCache(const IOdata& /*inputs*/, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!stateDataValue.updateRequired(linkInfo.seqID)) { return; @@ -733,7 +733,7 @@ int acdcConverter::fixPower(double /*power*/, } void acdcConverter::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { auto offset = offsets.getAlgOffset(sMode); diff --git a/src/griddyn/links/AcdcConverter.h b/src/griddyn/links/AcdcConverter.h index 992607dc3..2cb63f2db 100644 --- a/src/griddyn/links/AcdcConverter.h +++ b/src/griddyn/links/AcdcConverter.h @@ -67,14 +67,14 @@ namespace links { virtual double getMaxTransfer() const override; // virtual void pFlowCheck (std::vector &Violation_vector); - // virtual void getVariableType (double sdata[], const solverMode &sMode); //has no + // virtual void getVariableType (double sdata[], const SolverMode &sMode); //has no // state variables virtual void updateBus(GridBus* bus, index_t busnumber) override; virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void pFlowObjectInitializeA(coreTime time0, std::uint32_t flags) override; virtual void dynObjectInitializeA(coreTime time0, std::uint32_t flags) override; virtual void dynObjectInitializeB(const IOdata& inputs, @@ -82,7 +82,7 @@ namespace links { IOdata& fieldSet) override; virtual void - timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual double quickupdateP() override { return 0; } @@ -98,35 +98,35 @@ namespace links { const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(id_type_t busId, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void guessState(coreTime time, double state[], double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // for computing all the Jacobian elements at once virtual int fixRealPower(double power, id_type_t terminal, @@ -139,7 +139,7 @@ namespace links { units::unit unitType = units::defunit) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix = "") const override; private: diff --git a/src/griddyn/links/AdjustableTransformer.cpp b/src/griddyn/links/AdjustableTransformer.cpp index 83c006da2..4488541c0 100644 --- a/src/griddyn/links/AdjustableTransformer.cpp +++ b/src/griddyn/links/AdjustableTransformer.cpp @@ -466,7 +466,7 @@ void adjustableTransformer::pFlowObjectInitializeA(coreTime time0, std::uint32_t AcLine::pFlowObjectInitializeA(time0, flags); } -stateSizes adjustableTransformer::localStateSizes(const solverMode& sMode) const +stateSizes adjustableTransformer::localStateSizes(const SolverMode& sMode) const { stateSizes lcStates; if (isDynamic(sMode)) { @@ -489,7 +489,7 @@ stateSizes adjustableTransformer::localStateSizes(const solverMode& sMode) const return lcStates; } -count_t adjustableTransformer::localJacobianCount(const solverMode& sMode) const +count_t adjustableTransformer::localJacobianCount(const SolverMode& sMode) const { count_t localJacSize = 0; if (isDynamic(sMode)) { @@ -525,7 +525,7 @@ count_t adjustableTransformer::localJacobianCount(const solverMode& sMode) const } void adjustableTransformer::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { if (stateSize(sMode) > 0) { @@ -772,7 +772,7 @@ ChangeCode adjustableTransformer::powerFlowAdjust(const IOdata& /*inputs*/, void adjustableTransformer::guessState(coreTime /*time*/, double state[], double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); if ((!(isDynamic(sMode))) && (opFlags[has_pflow_states])) { @@ -792,7 +792,7 @@ void adjustableTransformer::ioPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& matrixDataRef, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if ((!(isDynamic(sMode))) && (opFlags[has_pflow_states])) { auto offset = offsets.getAlgOffset(sMode); @@ -809,7 +809,7 @@ void adjustableTransformer::ioPartialDerivatives(id_type_t busId, void adjustableTransformer::outputPartialDerivatives(const IOdata& inputs, const stateData& stateData, matrixData& matrixDataRef, - const solverMode& sMode) + const SolverMode& sMode) { // if the terminal is not specified assume there are 4 outputs if ((!(isDynamic(sMode))) && (opFlags[has_pflow_states])) { @@ -834,7 +834,7 @@ void adjustableTransformer::outputPartialDerivatives(const IOdata& inputs, void adjustableTransformer::outputPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& matrixDataRef, - const solverMode& sMode) + const SolverMode& sMode) { if ((!(isDynamic(sMode))) && (opFlags[has_pflow_states])) { auto offset = offsets.getAlgOffset(sMode); @@ -854,7 +854,7 @@ void adjustableTransformer::jacobianElements(const IOdata& /*inputs*/, const stateData& stateData, matrixData& matrixDataRef, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if ((!(isDynamic(sMode))) && (opFlags[has_pflow_states])) { auto offset = offsets.getAlgOffset(sMode); @@ -883,7 +883,7 @@ void adjustableTransformer::jacobianElements(const IOdata& /*inputs*/, void adjustableTransformer::residual(const IOdata& /*inputs*/, const stateData& stateData, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { double voltage1; @@ -939,7 +939,7 @@ void adjustableTransformer::residual(const IOdata& /*inputs*/, void adjustableTransformer::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getAlgOffset(sMode); if ((!(isDynamic(sMode))) && (opFlags[has_pflow_states])) { @@ -970,7 +970,7 @@ void adjustableTransformer::updateLocalCache() } void adjustableTransformer::updateLocalCache(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) + const SolverMode& sMode) { if ((!(isDynamic(sMode))) && (opFlags[has_pflow_states])) { auto offset = offsets.getAlgOffset(sMode); @@ -986,7 +986,7 @@ void adjustableTransformer::updateLocalCache(const IOdata& inputs, } } -count_t adjustableTransformer::outputDependencyCount(index_t /*num*/, const solverMode& sMode) const +count_t adjustableTransformer::outputDependencyCount(index_t /*num*/, const SolverMode& sMode) const { if ((!(isDynamic(sMode))) && (opFlags[has_pflow_states])) { return 3; @@ -997,7 +997,7 @@ count_t adjustableTransformer::outputDependencyCount(index_t /*num*/, const solv void adjustableTransformer::rootTest(const IOdata& /*inputs*/, const stateData& stateData, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { double controlVoltage; @@ -1026,7 +1026,7 @@ void adjustableTransformer::rootTest(const IOdata& /*inputs*/, void adjustableTransformer::rootTrigger(coreTime /*time*/, const IOdata& /*inputs*/, const std::vector& /*rootMask*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { [[maybe_unused]] double voltage1; switch (cMode) { @@ -1057,7 +1057,7 @@ void adjustableTransformer::rootTrigger(coreTime /*time*/, void adjustableTransformer::tapAnglePartial(index_t busId, const stateData& /*sD*/, matrixData& matrixDataRef, - const solverMode& sMode) + const SolverMode& sMode) { if (!(isEnabled())) { return; @@ -1096,7 +1096,7 @@ void adjustableTransformer::tapAnglePartial(index_t busId, void adjustableTransformer::tapPartial(index_t busId, const stateData& /*sD*/, matrixData& matrixDataRef, - const solverMode& sMode) + const SolverMode& sMode) { if (!(isEnabled())) { return; @@ -1144,7 +1144,7 @@ void adjustableTransformer::tapPartial(index_t busId, void adjustableTransformer::MWJac(const stateData& /*sD*/, matrixData& matrixDataRef, - const solverMode& sMode) + const SolverMode& sMode) { if (!(isEnabled())) { return; @@ -1188,7 +1188,7 @@ void adjustableTransformer::MWJac(const stateData& /*sD*/, void adjustableTransformer::MVarJac(const stateData& /*sD*/, matrixData& matrixDataRef, - const solverMode& sMode) + const SolverMode& sMode) { if (!(isEnabled())) { return; diff --git a/src/griddyn/links/AdjustableTransformer.h b/src/griddyn/links/AdjustableTransformer.h index c02f74a03..fe144d4a7 100644 --- a/src/griddyn/links/AdjustableTransformer.h +++ b/src/griddyn/links/AdjustableTransformer.h @@ -118,13 +118,13 @@ which cases the parent of the link is searched for the bus*/ void updateLocalCache() override; void updateLocalCache(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) override; + const SolverMode& sMode) override; void jacobianElements(const IOdata& inputs, const stateData& stateData, matrixData& matrixDataRef, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; // for computing all the Jacobian elements at once using AcLine::ioPartialDerivatives; @@ -132,31 +132,31 @@ which cases the parent of the link is searched for the bus*/ const stateData& stateData, matrixData& matrixDataRef, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& stateData, matrixData& matrixDataRef, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& matrixDataRef, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; void residual(const IOdata& inputs, const stateData& stateData, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; void guessState(coreTime time, double state[], double dstateDt[], - const solverMode& sMode) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; protected: void pFlowObjectInitializeA(coreTime time0, std::uint32_t flags) override; @@ -166,53 +166,53 @@ which cases the parent of the link is searched for the bus*/ void rootTest(const IOdata& inputs, const stateData& stateData, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void followNetwork(int network, std::queue& stk) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix = "") const override; protected: /** @brief compute the Jacobian elements based on the MW control @param[in] stateData the stateData of the current state of the system @param[out] matrixDataRef the matrixData object to store the Jacobian information -@param[in] sMode the solverMode corresponding to the stateData +@param[in] sMode the SolverMode corresponding to the stateData */ void MWJac(const stateData& stateData, matrixData& matrixDataRef, - const solverMode& sMode); + const SolverMode& sMode); /** @brief compute the Jacobian elements based on the MVar control @param[in] stateData the stateData of the current state of the system @param[out] matrixDataRef the matrixData object to store the Jacobian information -@param[in] sMode the solverMode corresponding to the stateData +@param[in] sMode the SolverMode corresponding to the stateData */ void MVarJac(const stateData& stateData, matrixData& matrixDataRef, - const solverMode& sMode); + const SolverMode& sMode); /** @brief compute the partial derivatives of the power flows based on the tap angle @param[in] busId the id of the calling bus either 1 or 2 or a busID of one of the attached buses @param[in] stateData the stateData of the current state of the system @param[out] matrixDataRef the matrixData object to store the Jacobian information -@param[in] sMode the solverMode corresponding to the stateData +@param[in] sMode the SolverMode corresponding to the stateData */ void tapAnglePartial(index_t busId, const stateData& stateData, matrixData& matrixDataRef, - const solverMode& sMode); + const SolverMode& sMode); /** @brief compute the partial derivatives of the power flows based on the tap setting @param[in] busId the id of the calling bus either 1 or 2 or a busID of one of the attached buses @param[in] stateData the stateData of the current state of the system @param[out] matrixDataRef the matrixData object to store the Jacobian information -@param[in] sMode the solverMode corresponding to the stateData +@param[in] sMode the SolverMode corresponding to the stateData */ void tapPartial(index_t busId, const stateData& stateData, matrixData& matrixDataRef, - const solverMode& sMode); + const SolverMode& sMode); /** @brief do any stepped adjustments based on voltage control from the power flow calculations @return ChangeCode::NO_CHANGE if nothing was done, PARAMETER_ADJUSTMENT if the tap changer was diff --git a/src/griddyn/links/DcLink.cpp b/src/griddyn/links/DcLink.cpp index 1583e8dd9..f5b3835d8 100644 --- a/src/griddyn/links/DcLink.cpp +++ b/src/griddyn/links/DcLink.cpp @@ -45,7 +45,7 @@ CoreObject* dcLink::clone(CoreObject* obj) const return nobj; } -void dcLink::timestep(coreTime /*time*/, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void dcLink::timestep(coreTime /*time*/, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { if (!isEnabled()) { return; @@ -133,7 +133,7 @@ void dcLink::dynObjectInitializeA(coreTime /*time0*/, std::uint32_t /*flags*/) } } -stateSizes dcLink::localStateSizes(const solverMode& sMode) const +stateSizes dcLink::localStateSizes(const SolverMode& sMode) const { stateSizes localSS; if (isDynamic(sMode)) { @@ -148,7 +148,7 @@ stateSizes dcLink::localStateSizes(const solverMode& sMode) const return localSS; } -count_t dcLink::localJacobianCount(const solverMode& sMode) const +count_t dcLink::localJacobianCount(const SolverMode& sMode) const { count_t jacCount = 0; if (isDynamic(sMode)) { @@ -167,7 +167,7 @@ void dcLink::ioPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& jacobian, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { // check if line is enabled updateLocalCache(noInputs, stateData, sMode); @@ -185,7 +185,7 @@ void dcLink::ioPartialDerivatives(id_type_t busId, void dcLink::outputPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& jacobian, - const solverMode& sMode) + const SolverMode& sMode) { if (!(isEnabled())) { return; @@ -227,7 +227,7 @@ void dcLink::outputPartialDerivatives(id_type_t busId, } } -count_t dcLink::outputDependencyCount(index_t num, const solverMode& /*sMode*/) const +count_t dcLink::outputDependencyCount(index_t num, const SolverMode& /*sMode*/) const { return (num == PoutLocation) ? 1 : 0; } @@ -236,7 +236,7 @@ void dcLink::jacobianElements(const IOdata& /*inputs*/, const stateData& stateData, matrixData& jacobian, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if (stateSize(sMode) > 0) { const int bus1VoltageOffset = B1->getOutputLoc(sMode, voltageInLocation); @@ -264,7 +264,7 @@ void dcLink::jacobianElements(const IOdata& /*inputs*/, void dcLink::residual(const IOdata& inputs, const stateData& stateData, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (stateSize(sMode) > 0) { updateLocalCache(inputs, stateData, sMode); @@ -287,7 +287,7 @@ void dcLink::residual(const IOdata& inputs, void dcLink::setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { if (stateSize(sMode) > 0) { if (isDynamic(sMode)) { @@ -306,7 +306,7 @@ void dcLink::setState(coreTime time, void dcLink::guessState(const coreTime /*time*/, double state[], double dstateDt[], - const solverMode& sMode) + const SolverMode& sMode) { if (stateSize(sMode) > 0) { if (isDynamic(sMode)) { @@ -321,7 +321,7 @@ void dcLink::guessState(const coreTime /*time*/, } void dcLink::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { if (stateSize(sMode) > 0) { @@ -334,7 +334,7 @@ void dcLink::getStateName(stringVec& stNames, void dcLink::updateLocalCache(const IOdata& /*inputs*/, const stateData& stateData, - const solverMode& sMode) + const SolverMode& sMode) { if (!stateData.updateRequired(linkInfo.seqID)) { return; diff --git a/src/griddyn/links/DcLink.h b/src/griddyn/links/DcLink.h index d13d762da..12a1edae6 100644 --- a/src/griddyn/links/DcLink.h +++ b/src/griddyn/links/DcLink.h @@ -34,7 +34,7 @@ class dcLink: public Link { virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double getMaxTransfer() const override; virtual void pFlowObjectInitializeA(coreTime time0, std::uint32_t flags) override; @@ -42,10 +42,10 @@ class dcLink: public Link { virtual void dynObjectInitializeA(coreTime time0, std::uint32_t flags) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual double quickupdateP() override { return 0; } @@ -60,34 +60,34 @@ class dcLink: public Link { const stateData& stateData, matrixData& jacobian, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; using Link::outputPartialDerivatives; virtual void outputPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& jacobian, - const solverMode& sMode) override; + const SolverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void jacobianElements(const IOdata& inputs, const stateData& stateData, matrixData& jacobian, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& stateData, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void guessState(coreTime time, double state[], double dstateDt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // for computing all the Jacobian elements at once virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix = "") const override; virtual int fixRealPower(double power, id_type_t measureTerminal, diff --git a/src/griddyn/links/Link.cpp b/src/griddyn/links/Link.cpp index 4cef7807b..50cab862b 100644 --- a/src/griddyn/links/Link.cpp +++ b/src/griddyn/links/Link.cpp @@ -163,7 +163,7 @@ double Link::quickupdateP() { return Pset; } -void Link::timestep(const coreTime time, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void Link::timestep(const coreTime time, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { if (!isEnabled()) { return; @@ -478,24 +478,24 @@ void Link::ioPartialDerivatives(id_type_t /*busId*/, const stateData& /*sD*/, matrixData& /*md*/, const IOlocs& /*inputLocs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void Link::outputPartialDerivatives(id_type_t /*busId*/, const stateData& /*sD*/, matrixData& /*md*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } -count_t Link::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t Link::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 0; } IOdata Link::getOutputs(const IOdata& /*inputs*/, const stateData& stateData, - const solverMode& sMode) const + const SolverMode& sMode) const { return getOutputs(1, stateData, sMode); } @@ -505,7 +505,7 @@ static bool isBus2(id_type_t busId, GridBus* bus) return ((busId == 2) || (isSameObject(busId, bus))); } -IOdata Link::getOutputs(id_type_t busId, const stateData& /*sD*/, const solverMode& /*sMode*/) const +IOdata Link::getOutputs(id_type_t busId, const stateData& /*sD*/, const SolverMode& /*sMode*/) const { // set from/to buses IOdata out{0.0, 0.0}; @@ -582,7 +582,7 @@ double Link::getBusAngle(id_type_t busId) const return kNullVal; } -double Link::getBusAngle(const stateData& stateData, const solverMode& sMode, id_type_t busId) const +double Link::getBusAngle(const stateData& stateData, const SolverMode& sMode, id_type_t busId) const { if (busId < 500_ind) { const auto* bus = getBus(static_cast(busId)); @@ -616,14 +616,14 @@ double Link::getVoltage(id_type_t busId) const void Link::setState(coreTime time, const double /*state*/[], const double /*dstate_dt*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { prevTime = time; } void Link::updateLocalCache(const IOdata& /*inputs*/, const stateData& stateData, - const solverMode& sMode) + const SolverMode& sMode) { if (!isEnabled()) { return; @@ -689,7 +689,7 @@ double Link::remainingCapacity() const { return getMaxTransfer() - std::abs(linkFlows.P1); } -double Link::getAngle(const double state[], const solverMode& sMode) const +double Link::getAngle(const double state[], const SolverMode& sMode) const { const double angle1 = B1->getAngle(state, sMode); const double angle2 = B2->getAngle(state, sMode); diff --git a/src/griddyn/links/Subsystem.cpp b/src/griddyn/links/Subsystem.cpp index 8fc532054..e2b5dfb05 100644 --- a/src/griddyn/links/Subsystem.cpp +++ b/src/griddyn/links/Subsystem.cpp @@ -152,7 +152,7 @@ void subsystem::updateLocalCache() } void subsystem::updateLocalCache(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) + const SolverMode& sMode) { subarea.updateLocalCache(inputs, stateData, sMode); } @@ -175,7 +175,7 @@ void subsystem::dynObjectInitializeA(coreTime time0, std::uint32_t flags) void subsystem::converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode mode, double tol) { @@ -304,7 +304,7 @@ double subsystem::get(std::string_view param, unit unitType) const return val; } -void subsystem::timestep(const coreTime time, const IOdata& inputs, const solverMode& sMode) +void subsystem::timestep(const coreTime time, const IOdata& inputs, const SolverMode& sMode) { subarea.timestep(time, inputs, sMode); prevTime = time; @@ -326,7 +326,7 @@ double subsystem::getLoss() const void subsystem::setState(const coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { subarea.setState(time, state, dstate_dt, sMode); prevTime = time; @@ -334,7 +334,7 @@ void subsystem::setState(const coreTime time, // next do any internal area states } -void subsystem::getVoltageStates(double vStates[], const solverMode& sMode) +void subsystem::getVoltageStates(double vStates[], const SolverMode& sMode) { subarea.getVoltageStates(vStates, sMode); @@ -436,7 +436,7 @@ double subsystem::getAngle() const return angleTerminal1 - angleTerminal2; } -double subsystem::getAngle(const double state[], const solverMode& sMode) const +double subsystem::getAngle(const double state[], const SolverMode& sMode) const { const double angleTerminal1 = terminalBus[0]->getAngle(state, sMode); const double angleTerminal2 = terminalBus[m_terminals - 1]->getAngle(state, sMode); @@ -569,7 +569,7 @@ void subsystem::ioPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& jacobian, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (busId <= 0) { busId = 1; @@ -586,7 +586,7 @@ void subsystem::ioPartialDerivatives(id_type_t busId, void subsystem::outputPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& jacobian, - const solverMode& sMode) + const SolverMode& sMode) { if (busId <= 0) { busId = 1; @@ -601,14 +601,14 @@ void subsystem::outputPartialDerivatives(id_type_t busId, IOdata subsystem::getOutputs(const IOdata& /*inputs*/, const stateData& stateData, - const solverMode& sMode) const + const SolverMode& sMode) const { return getOutputs(1, stateData, sMode); } IOdata subsystem::getOutputs(id_type_t busId, const stateData& /*stateData*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { IOdata out{Pout[0], Qout[0]}; diff --git a/src/griddyn/links/Subsystem.h b/src/griddyn/links/Subsystem.h index 0fad6a722..066ac10c6 100644 --- a/src/griddyn/links/Subsystem.h +++ b/src/griddyn/links/Subsystem.h @@ -63,7 +63,7 @@ class subsystem: public Link { // dynInitializeB dynamics virtual void dynObjectInitializeA(coreTime time0, std::uint32_t flags) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; /** @brief relic of something not used to my knowledge*/ virtual void updateTheta(coreTime /*time*/) {} @@ -92,27 +92,27 @@ class subsystem: public Link { virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; // for identifying which variables are algebraic vs differential /** @brief do a local converge on the components in the area a wrapper around the area->converge function @param[in] time the time @param[in] state the system state @param[in] dstate_dt the time derivative of the state - @param[in] sMode the solverMode corresponding to the state + @param[in] sMode the SolverMode corresponding to the state @param[in] tol the tolerance to do the convergence @param[in] mode the mode of convergence */ virtual void converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode mode = ConvergeMode::block_iteration, double tol = 0.01) override; virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void reset(ResetLevels level) override; // root finding functions @@ -121,9 +121,9 @@ class subsystem: public Link { /** @brief flag all the voltage states *@param[out] vStates a vector with a value of 1.0 for all voltage states and 0 otherwise - @param[in] sMode the solverMode to get the voltage state indicators for + @param[in] sMode the SolverMode to get the voltage state indicators for */ - void getVoltageStates(double vStates[], const solverMode& sMode); + void getVoltageStates(double vStates[], const SolverMode& sMode); bool switchTest() const override; bool switchTest(index_t num) const override; @@ -148,7 +148,7 @@ class subsystem: public Link { double remainingCapacity() const override; double getAngle() const override; - double getAngle(const double state[], const solverMode& sMode) const override; + double getAngle(const double state[], const SolverMode& sMode) const override; virtual double getRealImpedance(id_type_t busId = invalid_id_value) const override; virtual double getImagImpedance(id_type_t busId = invalid_id_value) const override; virtual double getTotalImpedance(id_type_t busId = invalid_id_value) const override; @@ -173,21 +173,21 @@ class subsystem: public Link { const stateData& stateData, matrixData& jacobian, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; using Link::outputPartialDerivatives; virtual void outputPartialDerivatives(id_type_t busId, const stateData& stateData, matrixData& jacobian, - const solverMode& sMode) override; + const SolverMode& sMode) override; // virtual void busResidual(index_t busId, const stateData &sD, double *Fp, double *Fq, const - // solverMode &sMode); + // SolverMode &sMode); virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual IOdata getOutputs(id_type_t busId, const stateData& stateData, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; // TODO(phlpt): Add the other getOutput functions. protected: /** @brief get a vector with pointers to all the buses diff --git a/src/griddyn/links/ZBreaker.cpp b/src/griddyn/links/ZBreaker.cpp index 0d2e97577..d66c700b0 100644 --- a/src/griddyn/links/ZBreaker.cpp +++ b/src/griddyn/links/ZBreaker.cpp @@ -101,7 +101,7 @@ void zBreaker::updateLocalCache() } void zBreaker::updateLocalCache(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { if (!isEnabled()) { return; diff --git a/src/griddyn/links/ZBreaker.h b/src/griddyn/links/ZBreaker.h index 791e81c83..a4717e1b7 100644 --- a/src/griddyn/links/ZBreaker.h +++ b/src/griddyn/links/ZBreaker.h @@ -34,7 +34,7 @@ class zBreaker: public Link { virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double quickupdateP() override; virtual int fixRealPower(double power, diff --git a/src/griddyn/loads/AggregateLoad.cpp b/src/griddyn/loads/AggregateLoad.cpp index ae27b93b4..8223c9461 100644 --- a/src/griddyn/loads/AggregateLoad.cpp +++ b/src/griddyn/loads/AggregateLoad.cpp @@ -266,7 +266,7 @@ void AggregateLoad::set(std::string_view param, double val, units::unit unitType void AggregateLoad::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { for (auto& ld : subLoads) { if (ld->stateSize(sMode) > 0) { @@ -278,7 +278,7 @@ void AggregateLoad::residual(const IOdata& inputs, void AggregateLoad::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { for (auto& ld : subLoads) { if (ld->diffSize(sMode) > 0) { @@ -290,7 +290,7 @@ void AggregateLoad::derivative(const IOdata& inputs, void AggregateLoad::outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& ld : subLoads) { if (ld->stateSize(sMode) > 0) { @@ -303,7 +303,7 @@ void AggregateLoad::ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& ld : subLoads) { ld->ioPartialDerivatives(inputs, sD, md, inputLocs, sMode); @@ -314,7 +314,7 @@ void AggregateLoad::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& ld : subLoads) { if (ld->stateSize(sMode) > 0) { @@ -323,7 +323,7 @@ void AggregateLoad::jacobianElements(const IOdata& inputs, } } -void AggregateLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void AggregateLoad::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { for (auto& ld : subLoads) { ld->timestep(time, inputs, sMode); @@ -332,7 +332,7 @@ void AggregateLoad::timestep(coreTime time, const IOdata& inputs, const solverMo double AggregateLoad::getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { double rp = 0; for (auto& ld : subLoads) { @@ -345,7 +345,7 @@ double AggregateLoad::getRealPower(const IOdata& inputs, double AggregateLoad::getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { double rp = 0; for (auto& ld : subLoads) { diff --git a/src/griddyn/loads/AggregateLoad.h b/src/griddyn/loads/AggregateLoad.h index 9680f943c..fb4aed63f 100644 --- a/src/griddyn/loads/AggregateLoad.h +++ b/src/griddyn/loads/AggregateLoad.h @@ -42,37 +42,37 @@ class AggregateLoad: public ZipLoad { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) override; // return D[0]=dP/dV D[1]=dP/dtheta,D[2]=dQ/dV,D[3]=dQ/dtheta virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual double getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getRealPower(double V) const override; virtual double getReactivePower(double V) const override; virtual double getRealPower() const override; diff --git a/src/griddyn/loads/ApproximatingLoad.cpp b/src/griddyn/loads/ApproximatingLoad.cpp index 38c595838..9c6212391 100644 --- a/src/griddyn/loads/ApproximatingLoad.cpp +++ b/src/griddyn/loads/ApproximatingLoad.cpp @@ -109,7 +109,7 @@ void ApproximatingLoad::dynObjectInitializeB(const IOdata& /*inputs*/, } } -void ApproximatingLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void ApproximatingLoad::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { const double voltage = inputs[voltageInLocation]; const double angle = inputs[angleInLocation]; @@ -234,7 +234,7 @@ coreTime ApproximatingLoad::updateB() void ApproximatingLoad::preEx(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if ((lastSeqID == stateDataValue.seqID) && (stateDataValue.seqID != 0)) { return; @@ -275,7 +275,7 @@ void ApproximatingLoad::preEx(const IOdata& inputs, void ApproximatingLoad::updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (opFlags[waiting_flag]) { updateB(); @@ -553,7 +553,7 @@ void ApproximatingLoad::set(std::string_view param, double val, units::unit unit void ApproximatingLoad::rootTest(const IOdata& inputs, const stateData& /*sD*/, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { const int rootOffset = offsets.getRootOffset(sMode); const double voltage = inputs[voltageInLocation]; @@ -565,7 +565,7 @@ void ApproximatingLoad::rootTest(const IOdata& inputs, void ApproximatingLoad::rootTrigger(coreTime time, const IOdata& /*inputs*/, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { const int rootOffset = offsets.getRootOffset(sMode); if (rootMask[rootOffset] != 0) { @@ -576,7 +576,7 @@ void ApproximatingLoad::rootTrigger(coreTime time, ChangeCode ApproximatingLoad::rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { const double voltage = inputs[voltageInLocation]; diff --git a/src/griddyn/loads/ApproximatingLoad.h b/src/griddyn/loads/ApproximatingLoad.h index 2b6dfffdf..5574578d6 100644 --- a/src/griddyn/loads/ApproximatingLoad.h +++ b/src/griddyn/loads/ApproximatingLoad.h @@ -40,10 +40,10 @@ namespace loads { IOdata& fieldSet) override; virtual void - timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void - preEx(const IOdata& inputs, const stateData& sD, const solverMode& sMode) override; + preEx(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) override; virtual void updateA(coreTime time) override; virtual coreTime updateB() override; @@ -56,19 +56,19 @@ namespace loads { virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; /** @brief return a count of the number of MPI objects the load requires*/ virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; private: // double abstime; diff --git a/src/griddyn/loads/ExponentialLoad.cpp b/src/griddyn/loads/ExponentialLoad.cpp index 297508d90..b1e008b76 100644 --- a/src/griddyn/loads/ExponentialLoad.cpp +++ b/src/griddyn/loads/ExponentialLoad.cpp @@ -52,7 +52,7 @@ void ExponentialLoad::ioPartialDerivatives(const IOdata& inputs, const stateData& /*sD*/, matrixData& md, const IOlocs& inputLocs, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { const double V = inputs[voltageInLocation]; // power vs voltage @@ -78,14 +78,14 @@ double ExponentialLoad::getReactivePower() const } double ExponentialLoad::getRealPower(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return getRealPower(inputs[voltageInLocation]); } double ExponentialLoad::getReactivePower(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return getReactivePower(inputs[voltageInLocation]); } diff --git a/src/griddyn/loads/ExponentialLoad.h b/src/griddyn/loads/ExponentialLoad.h index 2f39f5ee7..d6aa6e26e 100644 --- a/src/griddyn/loads/ExponentialLoad.h +++ b/src/griddyn/loads/ExponentialLoad.h @@ -36,13 +36,13 @@ class ExponentialLoad: public GridLoad { const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getRealPower(double V) const override; virtual double getReactivePower(double V) const override; virtual double getRealPower() const override; diff --git a/src/griddyn/loads/FDepLoad.cpp b/src/griddyn/loads/FDepLoad.cpp index 10a78bc4b..cddf625b0 100644 --- a/src/griddyn/loads/FDepLoad.cpp +++ b/src/griddyn/loads/FDepLoad.cpp @@ -104,7 +104,7 @@ void FDepLoad::ioPartialDerivatives(const IOdata& inputs, const stateData& /*sD*/, matrixData& md, const IOlocs& inputLocs, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { const double V = inputs[voltageInLocation]; double freq = inputs[frequencyInLocation]; @@ -139,14 +139,14 @@ double FDepLoad::getReactivePower() const } double FDepLoad::getRealPower(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return getRealPower(inputs[voltageInLocation], inputs[frequencyInLocation]); } double FDepLoad::getReactivePower(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return getReactivePower(inputs[voltageInLocation], inputs[frequencyInLocation]); } diff --git a/src/griddyn/loads/FDepLoad.h b/src/griddyn/loads/FDepLoad.h index 775ebf8eb..c9dbf0017 100644 --- a/src/griddyn/loads/FDepLoad.h +++ b/src/griddyn/loads/FDepLoad.h @@ -38,13 +38,13 @@ class FDepLoad: public ExponentialLoad { const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual double getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getRealPower(double V) const override; virtual double getReactivePower(double V) const override; virtual double getRealPower() const override; diff --git a/src/griddyn/loads/FileLoad.cpp b/src/griddyn/loads/FileLoad.cpp index a70f3eebc..febea8b5b 100644 --- a/src/griddyn/loads/FileLoad.cpp +++ b/src/griddyn/loads/FileLoad.cpp @@ -152,7 +152,7 @@ void FileLoad::updateA(coreTime time) nextUpdateTime = (currIndex == count - 1) ? maxTime : schedLoad.time(currIndex + 1); } -void FileLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void FileLoad::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { if (time >= nextUpdateTime) { updateA(time); diff --git a/src/griddyn/loads/FileLoad.h b/src/griddyn/loads/FileLoad.h index 46f1d616b..7e5f72786 100644 --- a/src/griddyn/loads/FileLoad.h +++ b/src/griddyn/loads/FileLoad.h @@ -39,7 +39,7 @@ class FileLoad: public RampLoad { virtual void updateA(coreTime time) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void setFlag(std::string_view flag, bool val = true) override; virtual void set(std::string_view param, std::string_view val) override; diff --git a/src/griddyn/loads/FrequencySensitiveLoad.cpp b/src/griddyn/loads/FrequencySensitiveLoad.cpp index a894f23e6..3499d5e95 100644 --- a/src/griddyn/loads/FrequencySensitiveLoad.cpp +++ b/src/griddyn/loads/FrequencySensitiveLoad.cpp @@ -48,7 +48,7 @@ void FrequencySensitiveLoad::dynObjectInitializeA(coreTime time0, std::uint32_t GridLoad::dynObjectInitializeA(time0, flags); } -void FrequencySensitiveLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void FrequencySensitiveLoad::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { subLoad->timestep(time, inputs, sMode); double freq = (inputs.size() > 2) ? inputs[frequencyInLocation] : 1.0; @@ -119,7 +119,7 @@ void FrequencySensitiveLoad::set(std::string_view param, double val, unit unitTy void FrequencySensitiveLoad::updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) + const SolverMode& sMode) { subLoad->updateLocalCache(inputs, sD, sMode); double freq = (inputs.size() >= frequencyInLocation) ? inputs[frequencyInLocation] : @@ -130,7 +130,7 @@ void FrequencySensitiveLoad::updateLocalCache(const IOdata& inputs, void FrequencySensitiveLoad::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { subLoad->setState(time, state, dstate_dt, sMode); updateOutputs(bus->getFreq()); @@ -149,7 +149,7 @@ double FrequencySensitiveLoad::getReactivePower() const double FrequencySensitiveLoad::getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { double Pr = subLoad->getRealPower(inputs, sD, sMode); double freq = (inputs.size() >= frequencyInLocation) ? inputs[frequencyInLocation] : @@ -159,7 +159,7 @@ double FrequencySensitiveLoad::getRealPower(const IOdata& inputs, double FrequencySensitiveLoad::getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { double Qr = subLoad->getReactivePower(inputs, sD, sMode); double freq = (inputs.size() >= frequencyInLocation) ? inputs[frequencyInLocation] : @@ -184,7 +184,7 @@ double FrequencySensitiveLoad::getReactivePower(double voltage) const void FrequencySensitiveLoad::outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) + const SolverMode& sMode) { if (inputs.empty()) // we only have output derivatives if the input arguments are not counted { @@ -194,7 +194,7 @@ void FrequencySensitiveLoad::outputPartialDerivatives(const IOdata& inputs, } } -count_t FrequencySensitiveLoad::outputDependencyCount(index_t num, const solverMode& sMode) const +count_t FrequencySensitiveLoad::outputDependencyCount(index_t num, const SolverMode& sMode) const { return subLoad->outputDependencyCount(num, sMode); } @@ -203,7 +203,7 @@ void FrequencySensitiveLoad::ioPartialDerivatives(const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /*md*/, const IOlocs& /*inputLocs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } diff --git a/src/griddyn/loads/FrequencySensitiveLoad.h b/src/griddyn/loads/FrequencySensitiveLoad.h index 3175d5214..e56c6e720 100644 --- a/src/griddyn/loads/FrequencySensitiveLoad.h +++ b/src/griddyn/loads/FrequencySensitiveLoad.h @@ -30,7 +30,7 @@ class FrequencySensitiveLoad: public GridLoad { virtual void dynObjectInitializeA(coreTime time0, std::uint32_t flags) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void getParameterStrings(stringVec& pstr, ParamStringType pstype) const override; virtual void set(std::string_view param, std::string_view val) override; @@ -43,31 +43,31 @@ class FrequencySensitiveLoad: public GridLoad { virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; /** update the actual outputs with a frequency related calculation*/ virtual void updateOutputs(double frequency); virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual double getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getRealPower(double V) const override; virtual double getReactivePower(double V) const override; virtual double getRealPower() const override; diff --git a/src/griddyn/loads/GridLabDLoad.cpp b/src/griddyn/loads/GridLabDLoad.cpp index aad350fdd..f9bfbc274 100644 --- a/src/griddyn/loads/GridLabDLoad.cpp +++ b/src/griddyn/loads/GridLabDLoad.cpp @@ -196,7 +196,7 @@ void GridLabDLoad::dynObjectInitializeB(const IOdata& /*inputs*/, } } -void GridLabDLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void GridLabDLoad::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { double V = inputs[voltageInLocation]; double th = inputs[angleInLocation]; @@ -348,7 +348,7 @@ coreTime GridLabDLoad::updateB() return nextUpdateTime; } -void GridLabDLoad::preEx(const IOdata& inputs, const stateData& sD, const solverMode& sMode) +void GridLabDLoad::preEx(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) { if ((lastSeqID == sD.seqID) && (sD.seqID != 0)) { return; @@ -389,7 +389,7 @@ void GridLabDLoad::preEx(const IOdata& inputs, const stateData& sD, const solver void GridLabDLoad::updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) + const SolverMode& sMode) { if (opFlags[waiting_flag]) { updateB(); @@ -979,7 +979,7 @@ void GridLabDLoad::set(std::string_view param, double val, units::unit unitType) void GridLabDLoad::rootTest(const IOdata& inputs, const stateData& /*sD*/, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { int rootOffset = offsets.getRootOffset(sMode); double V = inputs[voltageInLocation]; @@ -991,7 +991,7 @@ void GridLabDLoad::rootTest(const IOdata& inputs, void GridLabDLoad::rootTrigger(coreTime time, const IOdata& /*inputs*/, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { int rootOffset = offsets.getRootOffset(sMode); if (rootMask[rootOffset] != 0) { @@ -1002,7 +1002,7 @@ void GridLabDLoad::rootTrigger(coreTime time, ChangeCode GridLabDLoad::rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { double V = inputs[voltageInLocation]; diff --git a/src/griddyn/loads/GridLabDLoad.h b/src/griddyn/loads/GridLabDLoad.h index 9b5602eba..3c69c7371 100644 --- a/src/griddyn/loads/GridLabDLoad.h +++ b/src/griddyn/loads/GridLabDLoad.h @@ -39,10 +39,10 @@ namespace loads { IOdata& fieldSet) override; virtual void - timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void - preEx(const IOdata& inputs, const stateData& sD, const solverMode& sMode) override; + preEx(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) override; virtual void updateA(coreTime time) override; virtual coreTime updateB() override; @@ -55,20 +55,20 @@ namespace loads { virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; /** @brief return a count of the number of MPI objects the load requires*/ int mpiCount() const; virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; private: // double abstime; diff --git a/src/griddyn/loads/Load.cpp b/src/griddyn/loads/Load.cpp index 770888d07..c76f4b4a4 100644 --- a/src/griddyn/loads/Load.cpp +++ b/src/griddyn/loads/Load.cpp @@ -249,14 +249,14 @@ double GridLoad::getReactivePower() const } double GridLoad::getRealPower(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return getRealPower(); } double GridLoad::getReactivePower(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return getReactivePower(); } @@ -269,7 +269,7 @@ double GridLoad::getReactivePower(double /*V*/) const { return getReactivePower(); } -count_t GridLoad::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t GridLoad::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 0; } diff --git a/src/griddyn/loads/MotorLoad.cpp b/src/griddyn/loads/MotorLoad.cpp index bea35014d..3229c9cf4 100644 --- a/src/griddyn/loads/MotorLoad.cpp +++ b/src/griddyn/loads/MotorLoad.cpp @@ -96,7 +96,7 @@ void MotorLoad::dynObjectInitializeB(const IOdata& /*inputs*/, } } -stateSizes MotorLoad::localStateSizes(const solverMode& sMode) const +stateSizes MotorLoad::localStateSizes(const SolverMode& sMode) const { stateSizes stateSizeValues; if (isDynamic(sMode)) { @@ -109,7 +109,7 @@ stateSizes MotorLoad::localStateSizes(const solverMode& sMode) const return stateSizeValues; } -count_t MotorLoad::localJacobianCount(const solverMode& sMode) const +count_t MotorLoad::localJacobianCount(const SolverMode& sMode) const { count_t localJacSize = 0; if (isDynamic(sMode)) { @@ -122,7 +122,7 @@ count_t MotorLoad::localJacobianCount(const solverMode& sMode) const return localJacSize; } -std::pair MotorLoad::LocalRootCount(const solverMode& /*sMode*/) const +std::pair MotorLoad::LocalRootCount(const SolverMode& /*sMode*/) const { count_t algRoots = 0; count_t diffRoots = 0; @@ -224,7 +224,7 @@ void MotorLoad::set(std::string_view param, double val, units::unit unitType) void MotorLoad::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { if (isAlgebraicOnly(sMode)) { @@ -244,7 +244,7 @@ void MotorLoad::setState(coreTime time, void MotorLoad::guessState(coreTime /*time*/, double state[], double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { if (hasDifferential(sMode)) { @@ -262,7 +262,7 @@ void MotorLoad::guessState(coreTime /*time*/, void MotorLoad::residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { if (hasDifferential(sMode)) { @@ -280,7 +280,7 @@ void MotorLoad::residual(const IOdata& inputs, } void MotorLoad::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { if (isDynamic(sMode)) { @@ -297,7 +297,7 @@ void MotorLoad::getStateName(stringVec& stNames, return; } } -void MotorLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void MotorLoad::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { const double timeDelta = time - prevTime; MotorLoad::derivative(inputs, emptyStateData, m_dstate_dt.data(), cLocalSolverMode); @@ -307,7 +307,7 @@ void MotorLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& void MotorLoad::derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto offset = offsets.getDiffOffset(sMode); const double slip = (!stateDataValue.empty()) ? stateDataValue.state[offset] : m_state[0]; @@ -321,7 +321,7 @@ void MotorLoad::jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { if (hasDifferential(sMode)) { @@ -366,7 +366,7 @@ void MotorLoad::jacobianElements(const IOdata& inputs, void MotorLoad::outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { if (isAlgebraicOnly(sMode)) { @@ -409,7 +409,7 @@ void MotorLoad::outputPartialDerivatives(const IOdata& inputs, } } -count_t MotorLoad::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t MotorLoad::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 1; } @@ -417,7 +417,7 @@ void MotorLoad::ioPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (inputLocs[voltageInLocation] != kNullLocation) { double slip = m_state[0]; @@ -436,7 +436,7 @@ void MotorLoad::ioPartialDerivatives(const IOdata& inputs, } } -index_t MotorLoad::findIndex(std::string_view field, const solverMode& sMode) const +index_t MotorLoad::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if (field == "slip") { @@ -448,7 +448,7 @@ index_t MotorLoad::findIndex(std::string_view field, const solverMode& sMode) co void MotorLoad::rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(stateDataValue, sMode, this); const double slip = Loc.diffStateLoc[0]; @@ -463,7 +463,7 @@ void MotorLoad::rootTest(const IOdata& inputs, void MotorLoad::rootTrigger(coreTime /*time*/, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { if (rootMask[offsets.getRootOffset(sMode)] == 0) { return; @@ -483,7 +483,7 @@ void MotorLoad::rootTrigger(coreTime /*time*/, ChangeCode MotorLoad::rootCheck(const IOdata& inputs, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { if (opFlags[stalled]) { @@ -515,7 +515,7 @@ double MotorLoad::getReactivePower() const double MotorLoad::getRealPower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { const double voltage = inputs[voltageInLocation]; @@ -539,7 +539,7 @@ double MotorLoad::getRealPower(const IOdata& inputs, double MotorLoad::getReactivePower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { const double voltage = inputs[voltageInLocation]; double Qtemp; diff --git a/src/griddyn/loads/MotorLoad.h b/src/griddyn/loads/MotorLoad.h index c9a80b4c3..0a8c33545 100644 --- a/src/griddyn/loads/MotorLoad.h +++ b/src/griddyn/loads/MotorLoad.h @@ -68,58 +68,58 @@ class MotorLoad: public GridLoad { virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; // for saving the state + const SolverMode& sMode) override; // for saving the state virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; - virtual std::pair LocalRootCount(const solverMode& sMode) const override; + virtual std::pair LocalRootCount(const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) override; // return D[0]=dP/dV D[1]=dP/dtheta,D[2]=dQ/dV,D[3]=dQ/dtheta virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; virtual void rootTest(const IOdata& inputs, const stateData& stateDataValue, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; /** @brief compute the mechanical torque on the motor as a function of slip @@ -133,15 +133,15 @@ class MotorLoad: public GridLoad { */ double dmechds(double slip) const; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual double getRealPower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getRealPower(double V) const override; virtual double getReactivePower(double V) const override; virtual double getRealPower() const override; diff --git a/src/griddyn/loads/MotorLoad3.cpp b/src/griddyn/loads/MotorLoad3.cpp index e139a3fbb..8549a95b2 100644 --- a/src/griddyn/loads/MotorLoad3.cpp +++ b/src/griddyn/loads/MotorLoad3.cpp @@ -112,7 +112,7 @@ void MotorLoad3::dynObjectInitializeB(const IOdata& inputs, } } -stateSizes MotorLoad3::localStateSizes(const solverMode& sMode) const +stateSizes MotorLoad3::localStateSizes(const SolverMode& sMode) const { stateSizes SS; if (isDynamic(sMode)) { @@ -126,7 +126,7 @@ stateSizes MotorLoad3::localStateSizes(const solverMode& sMode) const return SS; } -count_t MotorLoad3::localJacobianCount(const solverMode& sMode) const +count_t MotorLoad3::localJacobianCount(const SolverMode& sMode) const { count_t localJacSize = 0; if (isDynamic(sMode)) { @@ -165,7 +165,7 @@ void MotorLoad3::set(std::string_view param, double val, units::unit unitType) void MotorLoad3::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { // NOLINTNEXTLINE GridComponent::setState(time, state, dstate_dt, sMode); @@ -174,7 +174,7 @@ void MotorLoad3::setState(coreTime time, void MotorLoad3::guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { // NOLINTNEXTLINE GridComponent::guessState(time, state, dstate_dt, sMode); @@ -184,7 +184,7 @@ void MotorLoad3::guessState(coreTime time, void MotorLoad3::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -252,7 +252,7 @@ void MotorLoad3::residual(const IOdata& inputs, } void MotorLoad3::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { std::string prefix2 = prefix + getName(); @@ -277,7 +277,7 @@ void MotorLoad3::getStateName(stringVec& stNames, } } -void MotorLoad3::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void MotorLoad3::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { stateData sD(time, m_state.data()); derivative(inputs, sD, m_dstate_dt.data(), cLocalSolverMode); @@ -289,7 +289,7 @@ void MotorLoad3::timestep(coreTime time, const IOdata& inputs, const solverMode& updateCurrents(inputs, sD, cLocalSolverMode); } -void MotorLoad3::updateCurrents(const IOdata& inputs, const stateData& sD, const solverMode& sMode) +void MotorLoad3::updateCurrents(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, const_cast(sD.state), sMode, this); double voltage = inputs[voltageInLocation]; @@ -311,7 +311,7 @@ void MotorLoad3::updateCurrents(const IOdata& inputs, const stateData& sD, const void MotorLoad3::derivative(const IOdata& /*inputs*/, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* ast = Loc.algStateLoc; @@ -342,7 +342,7 @@ void MotorLoad3::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { index_t refAlg; index_t refDiff; @@ -444,7 +444,7 @@ void MotorLoad3::jacobianElements(const IOdata& inputs, void MotorLoad3::outputPartialDerivatives(const IOdata& inputs, const stateData& /*sD*/, matrixData& md, - const solverMode& sMode) + const SolverMode& sMode) { auto refAlg = offsets.getAlgOffset(sMode); double voltage = inputs[voltageInLocation]; @@ -465,7 +465,7 @@ void MotorLoad3::outputPartialDerivatives(const IOdata& inputs, md.assign(QoutLocation, refAlg + 1, -vr * scale); } -count_t MotorLoad3::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t MotorLoad3::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 2; } @@ -473,7 +473,7 @@ void MotorLoad3::ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); @@ -501,7 +501,7 @@ void MotorLoad3::ioPartialDerivatives(const IOdata& inputs, vm * ir / voltage - vr * im / voltage); } -index_t MotorLoad3::findIndex(std::string_view field, const solverMode& sMode) const +index_t MotorLoad3::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if (field == "slip") { @@ -545,7 +545,7 @@ index_t MotorLoad3::findIndex(std::string_view field, const solverMode& sMode) c void MotorLoad3::rootTest(const IOdata& /*inputs*/, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); auto ro = offsets.getRootOffset(sMode); @@ -564,7 +564,7 @@ void MotorLoad3::rootTest(const IOdata& /*inputs*/, void MotorLoad3::rootTrigger(coreTime /*time*/, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { if (rootMask[offsets.getRootOffset(sMode)] == 0) { return; @@ -587,7 +587,7 @@ void MotorLoad3::rootTrigger(coreTime /*time*/, ChangeCode MotorLoad3::rootCheck(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel /*level*/) { if (opFlags[stalled]) { @@ -626,7 +626,7 @@ double MotorLoad3::getReactivePower() const double MotorLoad3::getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { const double voltage = inputs[voltageInLocation]; double angle = inputs[angleInLocation]; @@ -644,7 +644,7 @@ double MotorLoad3::getRealPower(const IOdata& inputs, double MotorLoad3::getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { const double voltage = inputs[voltageInLocation]; double angle = inputs[angleInLocation]; diff --git a/src/griddyn/loads/MotorLoad3.h b/src/griddyn/loads/MotorLoad3.h index 674ef9f2d..5537d6de4 100644 --- a/src/griddyn/loads/MotorLoad3.h +++ b/src/griddyn/loads/MotorLoad3.h @@ -40,71 +40,71 @@ class MotorLoad3: public MotorLoad { virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; // for saving the state + const SolverMode& sMode) override; // for saving the state virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) override; // return D[0]=dP/dV D[1]=dP/dtheta,D[2]=dQ/dV,D[3]=dQ/dtheta virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual double getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getRealPower(double voltage) const override; virtual double getReactivePower(double voltage) const override; virtual double getRealPower() const override; virtual double getReactivePower() const override; - virtual void updateCurrents(const IOdata& inputs, const stateData& sD, const solverMode& sMode); + virtual void updateCurrents(const IOdata& inputs, const stateData& sD, const SolverMode& sMode); private: /** @brief estimate the initial state values of the motor diff --git a/src/griddyn/loads/MotorLoad5.cpp b/src/griddyn/loads/MotorLoad5.cpp index 2e01a413d..3e69c5a99 100644 --- a/src/griddyn/loads/MotorLoad5.cpp +++ b/src/griddyn/loads/MotorLoad5.cpp @@ -137,7 +137,7 @@ void MotorLoad5::dynObjectInitializeB(const IOdata& inputs, } } -stateSizes MotorLoad5::localStateSizes(const solverMode& sMode) const +stateSizes MotorLoad5::localStateSizes(const SolverMode& sMode) const { stateSizes SS; if (isDynamic(sMode)) { @@ -151,7 +151,7 @@ stateSizes MotorLoad5::localStateSizes(const solverMode& sMode) const return SS; } -count_t MotorLoad5::localJacobianCount(const solverMode& sMode) const +count_t MotorLoad5::localJacobianCount(const SolverMode& sMode) const { count_t localJacSize = 0; if (isDynamic(sMode)) { @@ -193,7 +193,7 @@ void MotorLoad5::set(std::string_view param, double val, units::unit unitType) void MotorLoad5::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (isDynamic(sMode)) { auto Loc = offsets.getLocations(sD, resid, sMode, this); @@ -263,7 +263,7 @@ void MotorLoad5::residual(const IOdata& inputs, } void MotorLoad5::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { std::string prefix2 = prefix + getName(); @@ -291,7 +291,7 @@ void MotorLoad5::getStateName(stringVec& stNames, stNames[offset + 6] = prefix2 + ":empp"; } } -void MotorLoad5::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void MotorLoad5::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { stateData sD(time, m_state.data()); @@ -306,7 +306,7 @@ void MotorLoad5::timestep(coreTime time, const IOdata& inputs, const solverMode& updateCurrents(inputs, sD, cLocalSolverMode); } -void MotorLoad5::updateCurrents(const IOdata& inputs, const stateData& sD, const solverMode& sMode) +void MotorLoad5::updateCurrents(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, const_cast(sD.state), sMode, this); double voltage = inputs[voltageInLocation]; @@ -328,7 +328,7 @@ void MotorLoad5::updateCurrents(const IOdata& inputs, const stateData& sD, const void MotorLoad5::derivative(const IOdata& /*inputs*/, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, deriv, sMode, this); const double* ast = Loc.algStateLoc; @@ -363,7 +363,7 @@ void MotorLoad5::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { index_t refAlg; const double* gm; @@ -482,7 +482,7 @@ void MotorLoad5::jacobianElements(const IOdata& inputs, md.assign(refDiff + 4, refDiff + 4, -cj); } -index_t MotorLoad5::findIndex(std::string_view field, const solverMode& sMode) const +index_t MotorLoad5::findIndex(std::string_view field, const SolverMode& sMode) const { index_t ret = kInvalidLocation; if (field == "erpp") { @@ -515,7 +515,7 @@ index_t MotorLoad5::findIndex(std::string_view field, const solverMode& sMode) c void MotorLoad5::rootTest(const IOdata& /*inputs*/, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { auto Loc = offsets.getLocations(sD, sMode, this); auto ro = offsets.getRootOffset(sMode); @@ -532,7 +532,7 @@ void MotorLoad5::rootTest(const IOdata& /*inputs*/, void MotorLoad5::rootTrigger(coreTime /*time*/, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { if (rootMask[offsets.getRootOffset(sMode)] == 0) { return; @@ -552,7 +552,7 @@ void MotorLoad5::rootTrigger(coreTime /*time*/, ChangeCode MotorLoad5::rootCheck(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel /*level*/) { if (opFlags[stalled]) { diff --git a/src/griddyn/loads/MotorLoad5.h b/src/griddyn/loads/MotorLoad5.h index 375f1a5d3..be0efae53 100644 --- a/src/griddyn/loads/MotorLoad5.h +++ b/src/griddyn/loads/MotorLoad5.h @@ -44,47 +44,47 @@ class MotorLoad5: public MotorLoad3 { virtual void set(std::string_view param, double val, units::unit unitType = units::defunit) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; - virtual index_t findIndex(std::string_view field, const solverMode& sMode) const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual index_t findIndex(std::string_view field, const SolverMode& sMode) const override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; // TODO(phlpt): Change to algebraic update. virtual void - updateCurrents(const IOdata& inputs, const stateData& sD, const solverMode& sMode) override; + updateCurrents(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) override; private: /** @brief estimate the initial state values of the motor diff --git a/src/griddyn/loads/RampLoad.cpp b/src/griddyn/loads/RampLoad.cpp index d70a3b97f..66b09329b 100644 --- a/src/griddyn/loads/RampLoad.cpp +++ b/src/griddyn/loads/RampLoad.cpp @@ -119,7 +119,7 @@ void RampLoad::set(std::string_view param, double val, unit unitType) void RampLoad::updateLocalCache(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { auto tdiff = sD.time - lastTime; if (tdiff == timeZero) { diff --git a/src/griddyn/loads/RampLoad.h b/src/griddyn/loads/RampLoad.h index c0b676cb3..e1037fc9e 100644 --- a/src/griddyn/loads/RampLoad.h +++ b/src/griddyn/loads/RampLoad.h @@ -34,7 +34,7 @@ namespace loads { virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; /** set the ramps to 0*/ void clearRamp(); }; diff --git a/src/griddyn/loads/SourceLoad.cpp b/src/griddyn/loads/SourceLoad.cpp index d3b37d189..18e2800b3 100644 --- a/src/griddyn/loads/SourceLoad.cpp +++ b/src/griddyn/loads/SourceLoad.cpp @@ -218,7 +218,7 @@ void SourceLoad::set(std::string_view param, std::string_view val) } } -void SourceLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void SourceLoad::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { for (const auto& src : getSubObjects()) { static_cast(src)->timestep(time, noInputs, sMode); @@ -231,7 +231,7 @@ void SourceLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& void SourceLoad::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { for (const auto& src : getSubObjects()) { src->setState(time, state, dstate_dt, sMode); @@ -303,7 +303,7 @@ void SourceLoad::dynObjectInitializeA(coreTime time0, std::uint32_t flags) void SourceLoad::updateLocalCache(const IOdata& /*inputs*/, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& src : sources) { src->updateLocalCache(noInputs, stateDataValue, sMode); diff --git a/src/griddyn/loads/SourceLoad.h b/src/griddyn/loads/SourceLoad.h index dab8cc811..ecf87ce5b 100644 --- a/src/griddyn/loads/SourceLoad.h +++ b/src/griddyn/loads/SourceLoad.h @@ -60,14 +60,14 @@ eventually will replace most of the shaped loads*/ virtual void updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void - timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; CoreObject* find(std::string_view obj) const override; diff --git a/src/griddyn/loads/Svd.cpp b/src/griddyn/loads/Svd.cpp index 757e75106..257286126 100644 --- a/src/griddyn/loads/Svd.cpp +++ b/src/griddyn/loads/Svd.cpp @@ -205,14 +205,14 @@ void Svd::dynObjectInitializeB(const IOdata& /*inputs*/, void Svd::setState(coreTime /*time*/, const double /*state*/[], const double /*dstate_dt*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void Svd::guessState(coreTime /*time*/, double /*state*/[], double /*dstate_dt*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } @@ -224,7 +224,7 @@ ChangeCode void Svd::reset(ResetLevels /*level*/) {} // for identifying which variables are algebraic vs differential -void Svd::getVariableType(double /*sdata*/[], const solverMode& /*sMode*/) {} +void Svd::getVariableType(double /*sdata*/[], const SolverMode& /*sMode*/) {} void Svd::set(std::string_view param, std::string_view val) { if ((param == "blocks") || (param == "block")) { @@ -319,21 +319,21 @@ void Svd::addBlock(int steps, double Qstep, units::unit unitType) void Svd::residual(const IOdata& /*inputs*/, const stateData& /*sD*/, double /*resid*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void Svd::derivative(const IOdata& /*inputs*/, const stateData& /*sD*/, double /*deriv*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void Svd::outputPartialDerivatives(const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /*md*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } @@ -341,33 +341,33 @@ void Svd::jacobianElements(const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /*md*/, const IOlocs& /*inputLocs*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void Svd::getStateName(stringVec& /*stNames*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, const std::string& /*prefix*/) const { } -void Svd::timestep(coreTime /*time*/, const IOdata& /*inputs*/, const solverMode& /*sMode*/) {} +void Svd::timestep(coreTime /*time*/, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) {} void Svd::rootTest(const IOdata& /*inputs*/, const stateData& /*sD*/, double /*roots*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void Svd::rootTrigger(coreTime /*time*/, const IOdata& /*inputs*/, const std::vector& /*rootMask*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } ChangeCode Svd::rootCheck(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { return ChangeCode::NO_CHANGE; diff --git a/src/griddyn/loads/Svd.h b/src/griddyn/loads/Svd.h index 9f8786147..4238ffa74 100644 --- a/src/griddyn/loads/Svd.h +++ b/src/griddyn/loads/Svd.h @@ -59,13 +59,13 @@ class Svd: public RampLoad { virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; // for saving the state + const SolverMode& sMode) override; // for saving the state virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; // for initial setting of the state + const SolverMode& sMode) override; // for initial setting of the state - virtual void getVariableType(double sdata[], const solverMode& sMode) override; + virtual void getVariableType(double sdata[], const SolverMode& sMode) override; virtual void set(std::string_view param, std::string_view val) override; virtual void @@ -89,40 +89,40 @@ class Svd: public RampLoad { virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; protected: diff --git a/src/griddyn/loads/ThreePhaseLoad.cpp b/src/griddyn/loads/ThreePhaseLoad.cpp index d73ae77d5..f6a9e479f 100644 --- a/src/griddyn/loads/ThreePhaseLoad.cpp +++ b/src/griddyn/loads/ThreePhaseLoad.cpp @@ -347,14 +347,14 @@ void ThreePhaseLoad::set(std::string_view param, double val, unit unitType) IOdata ThreePhaseLoad::getRealPower3Phase(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, PhaseType type) const { return getRealPower3Phase(type); } IOdata ThreePhaseLoad::getReactivePower3Phase(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, PhaseType type) const { return getReactivePower3Phase(type); diff --git a/src/griddyn/loads/ThreePhaseLoad.h b/src/griddyn/loads/ThreePhaseLoad.h index 5a8e24a8b..eb1691a3c 100644 --- a/src/griddyn/loads/ThreePhaseLoad.h +++ b/src/griddyn/loads/ThreePhaseLoad.h @@ -70,11 +70,11 @@ conversions to positive sequence values. // for saving the state virtual IOdata getRealPower3Phase(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, PhaseType type = PhaseType::abc) const; virtual IOdata getReactivePower3Phase(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, PhaseType type = PhaseType::abc) const; /** get the 3 phase real output power that based on the given voltage @param[in] V the bus voltage diff --git a/src/griddyn/loads/ZipLoad.cpp b/src/griddyn/loads/ZipLoad.cpp index e463976de..a3cfb8233 100644 --- a/src/griddyn/loads/ZipLoad.cpp +++ b/src/griddyn/loads/ZipLoad.cpp @@ -120,7 +120,7 @@ void ZipLoad::dynObjectInitializeA(coreTime /*time0*/, std::uint32_t flags) #endif } -void ZipLoad::timestep(coreTime time, const IOdata& inputs, const solverMode& /*sMode*/) +void ZipLoad::timestep(coreTime time, const IOdata& inputs, const SolverMode& /*sMode*/) { if (!isConnected()) { Pout = 0; @@ -454,7 +454,7 @@ double ZipLoad::getx() const void ZipLoad::updateLocalCache(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { lastTime = sD.time; } @@ -462,7 +462,7 @@ void ZipLoad::updateLocalCache(const IOdata& /*inputs*/, void ZipLoad::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { stateData sD(time, state, dstate_dt); updateLocalCache(noInputs, sD, sMode); @@ -502,7 +502,7 @@ double ZipLoad::getReactivePower() const } double - ZipLoad::getRealPower(const IOdata& inputs, const stateData& sD, const solverMode& sMode) const + ZipLoad::getRealPower(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) const { double voltage = (inputs.empty()) ? (bus->getVoltage(sD, sMode)) : inputs[voltageInLocation]; return getRealPower(voltage); @@ -510,7 +510,7 @@ double double ZipLoad::getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { double voltage = (inputs.empty()) ? (bus->getVoltage(sD, sMode)) : inputs[voltageInLocation]; return getReactivePower(voltage); @@ -541,7 +541,7 @@ double ZipLoad::getReactivePower(double voltage) const void ZipLoad::outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) + const SolverMode& sMode) { if (inputs.empty()) // we only have output derivatives if the input arguments are not counted { @@ -551,7 +551,7 @@ void ZipLoad::outputPartialDerivatives(const IOdata& inputs, } } -count_t ZipLoad::outputDependencyCount(index_t /*num*/, const solverMode& /*sMode*/) const +count_t ZipLoad::outputDependencyCount(index_t /*num*/, const SolverMode& /*sMode*/) const { return 0; } @@ -559,7 +559,7 @@ void ZipLoad::ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (sD.time != lastTime) { updateLocalCache(inputs, sD, sMode); diff --git a/src/griddyn/loads/ZipLoad.h b/src/griddyn/loads/ZipLoad.h index 440d5e8db..4069166c5 100644 --- a/src/griddyn/loads/ZipLoad.h +++ b/src/griddyn/loads/ZipLoad.h @@ -50,7 +50,7 @@ class ZipLoad: public GridLoad { virtual void dynObjectInitializeA(coreTime time0, std::uint32_t flags) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void getParameterStrings(stringVec& pstr, ParamStringType pstype) const override; virtual void set(std::string_view param, std::string_view val) override; @@ -63,30 +63,30 @@ class ZipLoad: public GridLoad { virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void ioPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; - virtual count_t outputDependencyCount(index_t num, const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual count_t outputDependencyCount(index_t num, const SolverMode& sMode) const override; virtual double getRealPower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getReactivePower(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getRealPower(double V) const override; virtual double getReactivePower(double V) const override; virtual double getRealPower() const override; diff --git a/src/griddyn/measurement/Condition.cpp b/src/griddyn/measurement/Condition.cpp index 53b0fe2db..c06e714e0 100644 --- a/src/griddyn/measurement/Condition.cpp +++ b/src/griddyn/measurement/Condition.cpp @@ -263,7 +263,7 @@ double Condition::evalCondition() return mEvalFunction(leftValue, rightValue, mCurrentMargin); } -double Condition::evalCondition(const stateData& stateDataValue, const solverMode& sMode) +double Condition::evalCondition(const stateData& stateDataValue, const SolverMode& sMode) { const double leftValue = mConditionLHS->grabData(stateDataValue, sMode); const double rightValue = @@ -279,7 +279,7 @@ double Condition::getVal(int side) const return mConditionLHS->grabData(); } -double Condition::getVal(int side, const stateData& stateDataValue, const solverMode& sMode) const +double Condition::getVal(int side, const stateData& stateDataValue, const SolverMode& sMode) const { if (side == 2) { return (mConstRHS) ? m_constant : mConditionRHS->grabData(stateDataValue, sMode); @@ -295,7 +295,7 @@ bool Condition::checkCondition() const return (isEqualityComparison(mComparison)) ? (conditionValue <= 0.0) : (conditionValue < 0.0); } -bool Condition::checkCondition(const stateData& stateDataValue, const solverMode& sMode) const +bool Condition::checkCondition(const stateData& stateDataValue, const SolverMode& sMode) const { const double leftValue = mConditionLHS->grabData(stateDataValue, sMode); const double rightValue = diff --git a/src/griddyn/measurement/Condition.h b/src/griddyn/measurement/Condition.h index f6d5127e7..9c1b78386 100644 --- a/src/griddyn/measurement/Condition.h +++ b/src/griddyn/measurement/Condition.h @@ -76,16 +76,16 @@ class Condition: public ObjectOperatorInterface { * @return returns a difference between the condition and parameter designed to go negative if *the condition is met **/ - virtual double evalCondition(const stateData& stateDataValue, const solverMode& sMode); + virtual double evalCondition(const stateData& stateDataValue, const SolverMode& sMode); /** *get the value for which the comparison is made @param[in] side either 1 for left hand side or 2 for right hand side @param[in] stateDataValue the state data from which to get the values - @param[in] sMode the solverMode related to the state data + @param[in] sMode the SolverMode related to the state data * @return returns the value for the comparison side=1 is left hand side, side=2 is the right hand side **/ - double getVal(int side, const stateData& stateDataValue, const solverMode& sMode) const; + double getVal(int side, const stateData& stateDataValue, const SolverMode& sMode) const; /** *get the value for which the comparison is made * @return returns the value for the comparison side=1 is left hand side, side=2 is the right @@ -105,7 +105,7 @@ class Condition: public ObjectOperatorInterface { @param[in] sMode the solver mode related to the data @return true if the condition evaluates true */ - virtual bool checkCondition(const stateData& stateDataValue, const solverMode& sMode) const; + virtual bool checkCondition(const stateData& stateDataValue, const SolverMode& sMode) const; /** set the comparison operator @param[in] comparison the comparison type*/ void setComparison(ComparisonType comparison); @@ -205,10 +205,10 @@ class compoundCondition: public Condition { compoundCondition() = default; virtual double evalCondition() override; - virtual double evalCondition(const stateData& stateDataValue, const solverMode& sMode) override; + virtual double evalCondition(const stateData& stateDataValue, const SolverMode& sMode) override; virtual bool checkCondition() const override; virtual bool checkCondition(const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; /** add a condition to the set of conditions to evaluate*/ void add(std::shared_ptr condition); /** set the compounding mode diff --git a/src/griddyn/measurement/GrabberSet.cpp b/src/griddyn/measurement/GrabberSet.cpp index 5ba411df0..d8e34f4b1 100644 --- a/src/griddyn/measurement/GrabberSet.cpp +++ b/src/griddyn/measurement/GrabberSet.cpp @@ -104,7 +104,7 @@ void grabberSet::grabData(std::vector& data) { mGrabber->grabVectorData(data); } -double grabberSet::grabData(const stateData& stateDataValue, const solverMode& sMode) +double grabberSet::grabData(const stateData& stateDataValue, const SolverMode& sMode) { if (mStateGrabber) { return mStateGrabber->grabData(stateDataValue, sMode); @@ -120,7 +120,7 @@ double grabberSet::grabData(const stateData& stateDataValue, const solverMode& s void grabberSet::outputPartialDerivatives(const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (mStateGrabber) { mStateGrabber->outputPartialDerivatives(stateDataValue, matrixDataValue, sMode); diff --git a/src/griddyn/measurement/GrabberSet.h b/src/griddyn/measurement/GrabberSet.h index 290e4e2db..e726c8bb2 100644 --- a/src/griddyn/measurement/GrabberSet.h +++ b/src/griddyn/measurement/GrabberSet.h @@ -25,7 +25,7 @@ class gridCore; class stateGrabber; class gridGrabber; class stateData; -class solverMode; +class SolverMode; /** class pairing up basicGrabbers and state grabbers in a single interface */ @@ -81,11 +81,11 @@ class grabberSet: public ObjectOperatorInterface { *@param[out] desc_list the list of descriptions **/ virtual void getDesc(std::vector& desc_list) const; - virtual double grabData(const stateData& stateDataValue, const solverMode& sMode); + virtual double grabData(const stateData& stateDataValue, const SolverMode& sMode); virtual void outputPartialDerivatives(const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode); - // virtual void getDoutDt(const stateData &sD, const solverMode &sMode) const; + const SolverMode& sMode); + // virtual void getDoutDt(const stateData &sD, const SolverMode &sMode) const; /** get a description of the grabberSet*/ virtual const std::string& getDesc() const; /** get a description of the grabber Set*/ diff --git a/src/griddyn/measurement/StateGrabber.h b/src/griddyn/measurement/StateGrabber.h index 90a97ee70..ac9c01315 100644 --- a/src/griddyn/measurement/StateGrabber.h +++ b/src/griddyn/measurement/StateGrabber.h @@ -23,9 +23,9 @@ namespace griddyn { using objJacFunction = std::function& matrixDataValue, - const solverMode& sMode)>; + const SolverMode& sMode)>; using objStateGrabberFunction = std::function< - double(GridComponent* comp, const stateData& stateDataValue, const solverMode& sMode)>; + double(GridComponent* comp, const stateData& stateDataValue, const SolverMode& sMode)>; /** define if the grabber can compute the Jacobian information*/ enum class JacobianMode { @@ -77,14 +77,14 @@ class stateGrabber: public ObjectOperatorInterface { @param[in] stateDataValue the stateData to grab the data from @param[in] sMode the solver mode associated with the stateData */ - virtual double grabData(const stateData& stateDataValue, const solverMode& sMode); + virtual double grabData(const stateData& stateDataValue, const SolverMode& sMode); /** compute the partial derivatives of a grabber @param[in] stateDataValue the stateData for computing the information @param[in] matrixDataValue the matrix to store the computed Jacobian information into - @param[in] sMode the solverMode associated with the stateData*/ + @param[in] sMode the SolverMode associated with the stateData*/ virtual void outputPartialDerivatives(const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode); + const SolverMode& sMode); virtual void updateObject(CoreObject* obj, ObjectUpdateMode mode = ObjectUpdateMode::DIRECT) override; virtual CoreObject* getObject() const override; @@ -108,7 +108,7 @@ class stateGrabber: public ObjectOperatorInterface { }; using fstateobjectPair = std::pair< - std::function, + std::function, units::unit>; /** construct a vector of state grabbers from a specific command string @@ -153,10 +153,10 @@ class stateFunctionGrabber: public stateGrabber { stateFunctionGrabber(std::shared_ptr ggb, std::string func); virtual std::unique_ptr clone() const override; virtual void cloneTo(stateGrabber* ggb) const override; - virtual double grabData(const stateData& stateDataValue, const solverMode& sMode) override; + virtual double grabData(const stateData& stateDataValue, const SolverMode& sMode) override; virtual void outputPartialDerivatives(const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void updateObject(CoreObject* obj, ObjectUpdateMode mode = ObjectUpdateMode::DIRECT) override; virtual CoreObject* getObject() const override; @@ -180,10 +180,10 @@ class stateOpGrabber: public stateGrabber { std::string operationName); virtual std::unique_ptr clone() const override; virtual void cloneTo(stateGrabber* ggb) const override; - virtual double grabData(const stateData& stateDataValue, const solverMode& sMode) override; + virtual double grabData(const stateData& stateDataValue, const SolverMode& sMode) override; virtual void outputPartialDerivatives(const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void updateObject(CoreObject* obj, ObjectUpdateMode mode = ObjectUpdateMode::DIRECT) override; /** overload for updating an object to a specific number of the underlying stateGrabbers diff --git a/src/griddyn/measurement/compoundCondition.cpp b/src/griddyn/measurement/compoundCondition.cpp index 04002ebca..287deb425 100644 --- a/src/griddyn/measurement/compoundCondition.cpp +++ b/src/griddyn/measurement/compoundCondition.cpp @@ -19,7 +19,7 @@ double compoundCondition::evalCondition() { return 0.0; } -double compoundCondition::evalCondition(const stateData& /*sD*/, const solverMode& /*sMode*/) +double compoundCondition::evalCondition(const stateData& /*sD*/, const SolverMode& /*sMode*/) { return 0.0; } @@ -42,7 +42,7 @@ bool compoundCondition::checkCondition() const } bool compoundCondition::checkCondition(const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { unsigned int trueConditionCount = 0; for (const auto& condition : mConditions) { diff --git a/src/griddyn/measurement/stateGrabbers.cpp b/src/griddyn/measurement/stateGrabbers.cpp index 3844ed4c3..6d8c6e15b 100644 --- a/src/griddyn/measurement/stateGrabbers.cpp +++ b/src/griddyn/measurement/stateGrabbers.cpp @@ -38,14 +38,14 @@ namespace { double secondaryRealPower(GridComponent* obj, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { return static_cast(obj)->getRealPower(noInputs, stateDataValue, sMode); } double secondaryReactivePower(GridComponent* obj, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { return static_cast(obj)->getReactivePower(noInputs, stateDataValue, sMode); } @@ -218,20 +218,20 @@ static const std::map stringTranslate{ }; #define FUNCTION_SIGNATURE \ - [](GridComponent * obj, const stateData& stateDataValue, const solverMode& sMode) + [](GridComponent * obj, const stateData& stateDataValue, const SolverMode& sMode) #define FUNCTION_SIGNATURE_OBJ_ONLY \ - [](GridComponent * obj, const stateData& /*sD*/, const solverMode& /*sMode*/) + [](GridComponent * obj, const stateData& /*sD*/, const SolverMode& /*sMode*/) #define JAC_FUNCTION_SIGNATURE \ [](GridComponent * obj, \ const stateData& stateDataValue, \ matrixData& matrixDataValue, \ - const solverMode& sMode) + const SolverMode& sMode) #define JAC_FUNCTION_SIGNATURE_NO_STATE \ [](GridComponent * obj, \ const stateData& /*sD*/, \ matrixData& matrixDataValue, \ - const solverMode& sMode) + const SolverMode& sMode) // clang-format off static const std::map objectFunctions{ @@ -359,14 +359,14 @@ void stateGrabber::objectLoadInfo(std::string_view fld) if ((fieldStr == "value") || (fieldStr == "output") || (fieldStr == "o")) { fptr = [num](GridComponent* comp, const stateData& stateDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { return comp->getOutput(noInputs, stateDataValue, sMode, static_cast(num)); }; } if ((fieldStr == "deriv") || (fieldStr == "doutdt") || (fieldStr == "derivative")) { fptr = [num](GridComponent* comp, const stateData& stateDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { return comp->getDoutdt(noInputs, stateDataValue, sMode, static_cast(num)); }; } else { @@ -374,7 +374,7 @@ void stateGrabber::objectLoadInfo(std::string_view fld) if (index != kNullLocation) { fptr = [index](GridComponent* comp, const stateData& stateDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { return comp->getOutput(noInputs, stateDataValue, sMode, index); }; } else { @@ -435,7 +435,7 @@ void stateGrabber::relayLoadInfo(std::string_view fld) if (dynamic_cast(cobj) != nullptr) { fptr = [num](GridComponent* comp, const stateData& stateDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { return static_cast(comp)->getBlockOutput(stateDataValue, sMode, num); }; } else { @@ -445,7 +445,7 @@ void stateGrabber::relayLoadInfo(std::string_view fld) if (dynamic_cast(cobj) != nullptr) { fptr = [num](GridComponent* comp, const stateData& stateDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { return static_cast(comp)->getBlockDerivOutput(stateDataValue, sMode, num); }; } else { @@ -455,7 +455,7 @@ void stateGrabber::relayLoadInfo(std::string_view fld) if (dynamic_cast(cobj) != nullptr) { fptr = [num](GridComponent* comp, const stateData& stateDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { return static_cast(comp)->getInput(stateDataValue, sMode, num); }; } else { @@ -465,7 +465,7 @@ void stateGrabber::relayLoadInfo(std::string_view fld) // dgptr = &Link::getAngle; fptr = [num](GridComponent* comp, const stateData& stateDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { return (static_cast(comp))->getCondition(num)->getVal(1, stateDataValue, sMode); }; } else { @@ -477,14 +477,14 @@ void stateGrabber::secondaryLoadInfo(std::string_view fld) { if ((fld == "realpower") || (fld == "power") || (fld == "p")) { cacheUpdateRequired = true; - fptr = [](GridComponent* comp, const stateData& stateDataValue, const solverMode& sMode) { + fptr = [](GridComponent* comp, const stateData& stateDataValue, const SolverMode& sMode) { return static_cast(comp)->getRealPower(noInputs, stateDataValue, sMode); }; jacMode = JacobianMode::COMPUTED; jacIfptr = [](GridComponent* comp, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { matrixDataTranslate<1, double> translatedMatrix(matrixDataValue); translatedMatrix.setTranslation(PoutLocation, 0); static_cast(comp)->outputPartialDerivatives(noInputs, @@ -494,7 +494,7 @@ void stateGrabber::secondaryLoadInfo(std::string_view fld) }; } else if ((fld == "reactivepower") || (fld == "reactive") || (fld == "q")) { cacheUpdateRequired = true; - fptr = [](GridComponent* comp, const stateData& stateDataValue, const solverMode& sMode) { + fptr = [](GridComponent* comp, const stateData& stateDataValue, const SolverMode& sMode) { return static_cast(comp)->getReactivePower(noInputs, stateDataValue, sMode); @@ -503,7 +503,7 @@ void stateGrabber::secondaryLoadInfo(std::string_view fld) jacIfptr = [](GridComponent* comp, const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { matrixDataTranslate<1, double> translatedMatrix(matrixDataValue); translatedMatrix.setTranslation(QoutLocation, 0); static_cast(comp)->outputPartialDerivatives(noInputs, @@ -517,7 +517,7 @@ void stateGrabber::secondaryLoadInfo(std::string_view fld) prevIndex = 1; fptr = [this](GridComponent* comp, const stateData& stateDataValue, - const solverMode& sMode) { + const SolverMode& sMode) { if (sMode.offsetIndex != prevIndex) { offset = static_cast(comp)->findIndex(field, sMode); prevIndex = sMode.offsetIndex; @@ -528,7 +528,7 @@ void stateGrabber::secondaryLoadInfo(std::string_view fld) jacIfptr = [this](GridComponent* /*comp*/, const stateData& /*sD*/, matrixData& matrixDataValue, - const solverMode& /*sMode*/) { + const SolverMode& /*sMode*/) { matrixDataValue.assignCheckCol(0, offset, 1.0); }; } else { @@ -538,7 +538,7 @@ void stateGrabber::secondaryLoadInfo(std::string_view fld) } void stateGrabber::areaLoadInfo(std::string_view /*fld*/) {} -double stateGrabber::grabData(const stateData& stateDataValue, const solverMode& sMode) +double stateGrabber::grabData(const stateData& stateDataValue, const SolverMode& sMode) { if (loaded) { if (cacheUpdateRequired) { @@ -570,7 +570,7 @@ void stateGrabber::getObjects(std::vector& objects) const } void stateGrabber::outputPartialDerivatives(const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (jacMode == JacobianMode::NONE) { return; @@ -670,7 +670,7 @@ void stateFunctionGrabber::cloneTo(stateGrabber* ggb) const sfg->dopptr = dopptr; } -double stateFunctionGrabber::grabData(const stateData& stateDataValue, const solverMode& sMode) +double stateFunctionGrabber::grabData(const stateData& stateDataValue, const SolverMode& sMode) { double val = opptr(bgrabber->grabData(stateDataValue, sMode)); val = std::fma(val, gain, bias); @@ -690,7 +690,7 @@ CoreObject* stateFunctionGrabber::getObject() const } void stateFunctionGrabber::outputPartialDerivatives(const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (jacMode == JacobianMode::NONE) { return; @@ -771,7 +771,7 @@ void stateOpGrabber::cloneTo(stateGrabber* ggb) const sog->opptr = opptr; } -double stateOpGrabber::grabData(const stateData& stateDataValue, const solverMode& sMode) +double stateOpGrabber::grabData(const stateData& stateDataValue, const SolverMode& sMode) { const double grabber1Data = bgrabber1->grabData(stateDataValue, sMode); const double grabber2Data = bgrabber2->grabData(stateDataValue, sMode); @@ -816,7 +816,7 @@ CoreObject* stateOpGrabber::getObject() const void stateOpGrabber::outputPartialDerivatives(const stateData& stateDataValue, matrixData& matrixDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (jacMode == JacobianMode::NONE) { return; diff --git a/src/griddyn/primary/AcBus.cpp b/src/griddyn/primary/AcBus.cpp index 8d88e5a6c..f4c66b613 100644 --- a/src/griddyn/primary/AcBus.cpp +++ b/src/griddyn/primary/AcBus.cpp @@ -954,7 +954,7 @@ void AcBus::generationAdjust(double adjustment) } } -void AcBus::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& sMode) +void AcBus::timestep(coreTime time, const IOdata& /*inputs*/, const SolverMode& sMode) { const double timeDelta = time - prevTime; if (timeDelta < 1.0) { @@ -1204,7 +1204,7 @@ static const IOdata kNullVec; IOdata AcBus::getOutputs(const IOdata& /*inputs*/, const stateData& stateDataValue, - const solverMode& sMode) const + const SolverMode& sMode) const { if (isLocal(sMode) || stateDataValue.empty()) { return {voltage, angle, freq}; @@ -1216,7 +1216,7 @@ IOdata AcBus::getOutputs(const IOdata& /*inputs*/, static const IOlocs kNullLocations{kNullLocation, kNullLocation, kNullLocation}; -IOlocs AcBus::getOutputLocs(const solverMode& sMode) const +IOlocs AcBus::getOutputLocs(const SolverMode& sMode) const { if ((!hasAlgebraic(sMode)) || (!isConnected())) { return kNullLocations; @@ -1248,7 +1248,7 @@ IOlocs AcBus::getOutputLocs(const solverMode& sMode) const return newOutLocs; } -index_t AcBus::getOutputLoc(const solverMode& sMode, index_t num) const +index_t AcBus::getOutputLoc(const SolverMode& sMode, index_t num) const { if (sMode.offsetIndex == lastSmode) { if (num < 3) { @@ -1280,7 +1280,7 @@ index_t AcBus::getOutputLoc(const solverMode& sMode, index_t num) const } } -double AcBus::getVoltage(const double state[], const solverMode& sMode) const +double AcBus::getVoltage(const double state[], const SolverMode& sMode) const { if (isLocal(sMode)) { return voltage; @@ -1289,7 +1289,7 @@ double AcBus::getVoltage(const double state[], const solverMode& sMode) const return (voltageOffset != kNullLocation) ? state[voltageOffset] : voltage; } -double AcBus::getAngle(const double state[], const solverMode& sMode) const +double AcBus::getAngle(const double state[], const SolverMode& sMode) const { if (isLocal(sMode)) { return angle; @@ -1298,7 +1298,7 @@ double AcBus::getAngle(const double state[], const solverMode& sMode) const return (angleOffset != kNullLocation) ? state[angleOffset] : angle; } -double AcBus::getVoltage(const stateData& stateDataValue, const solverMode& sMode) const +double AcBus::getVoltage(const stateData& stateDataValue, const SolverMode& sMode) const { if (isLocal(sMode)) { return voltage; @@ -1320,7 +1320,7 @@ double AcBus::getVoltage(const stateData& stateDataValue, const solverMode& sMod return voltage; } -double AcBus::getAngle(const stateData& stateDataValue, const solverMode& sMode) const +double AcBus::getAngle(const stateData& stateDataValue, const SolverMode& sMode) const { if (isLocal(sMode)) { return angle; @@ -1340,7 +1340,7 @@ double AcBus::getAngle(const stateData& stateDataValue, const solverMode& sMode) return angle; } -double AcBus::getFreq(const stateData& stateDataValue, const solverMode& sMode) const +double AcBus::getFreq(const stateData& stateDataValue, const SolverMode& sMode) const { double frequencyValue = freq; if (opFlags[uses_bus_frequency]) { @@ -1468,7 +1468,7 @@ void AcBus::removePowerControl(GridComponent* comp) } // guessState the solution -void AcBus::guessState(coreTime time, double state[], double dstate_dt[], const solverMode& sMode) +void AcBus::guessState(coreTime time, double state[], double dstate_dt[], const SolverMode& sMode) { auto Voffset = offsets.getVOffset(sMode); auto Aoffset = offsets.getAOffset(sMode); @@ -1492,7 +1492,7 @@ void AcBus::guessState(coreTime time, double state[], double dstate_dt[], const } // set algebraic and dynamic variables assume preset to differential -void AcBus::getVariableType(double sdata[], const solverMode& sMode) +void AcBus::getVariableType(double sdata[], const SolverMode& sMode) { auto Voffset = offsets.getVOffset(sMode); if (Voffset != kNullLocation) { @@ -1506,7 +1506,7 @@ void AcBus::getVariableType(double sdata[], const solverMode& sMode) GridComponent::getVariableType(sdata, sMode); } -void AcBus::getTols(double tols[], const solverMode& sMode) +void AcBus::getTols(double tols[], const SolverMode& sMode) { auto Voffset = offsets.getVOffset(sMode); if (Voffset != kNullLocation) { @@ -1524,7 +1524,7 @@ void AcBus::getTols(double tols[], const solverMode& sMode) void AcBus::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { auto Aoffset = offsets.getAOffset(sMode); auto Voffset = offsets.getVOffset(sMode); @@ -1569,7 +1569,7 @@ void AcBus::setState(coreTime time, void AcBus::residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { GridBus::residual(inputs, stateDataValue, resid, sMode); @@ -1624,7 +1624,7 @@ void AcBus::residual(const IOdata& inputs, void AcBus::derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { GridBus::derivative(inputs, stateDataValue, deriv, sMode); if (opFlags[compute_frequency]) { @@ -1637,7 +1637,7 @@ void AcBus::jacobianElements(const IOdata& inputs, const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { GridBus::jacobianElements(inputs, stateDataValue, matrixDataValue, inputLocs, sMode); @@ -1720,7 +1720,7 @@ void AcBus::jacobianElements(const IOdata& inputs, void AcBus::voltageUpdate(const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { if (!isConnected()) { @@ -1764,7 +1764,7 @@ void AcBus::voltageUpdate(const stateData& stateDataValue, void AcBus::algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { auto Voffset = offsets.getVOffset(sMode); @@ -1856,7 +1856,7 @@ void AcBus::algebraicUpdate(const IOdata& inputs, GridBus::algebraicUpdate(noInputs, stateDataValue, update, sMode, alpha); } -void AcBus::localConverge(const solverMode& sMode, int mode, double tol) +void AcBus::localConverge(const SolverMode& sMode, int mode, double tol) { if (isDifferentialOnly(sMode)) { return; @@ -1977,7 +1977,7 @@ void AcBus::localConverge(const solverMode& sMode, int mode, double tol) void AcBus::convergeHighErrorOnly(const stateData& stateDataValue, double state[], - const solverMode& sMode, + const SolverMode& sMode, double& err, double tol) { @@ -2003,7 +2003,7 @@ void AcBus::convergeHighErrorOnly(const stateData& stateDataValue, bool AcBus::convergeStrongIteration(const stateData& stateDataValue, double state[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode& mode, double& err, double& voltageValue, @@ -2042,7 +2042,7 @@ bool AcBus::convergeStrongIteration(const stateData& stateDataValue, bool AcBus::convergeVoltageOnly(const stateData& stateDataValue, double state[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode& mode, double& voltageValue, double angleValue, @@ -2160,7 +2160,7 @@ bool AcBus::convergeVoltageOnly(const stateData& stateDataValue, void AcBus::converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode mode, double tol) { @@ -2252,7 +2252,7 @@ void AcBus::converge(coreTime time, } } -double AcBus::computeError(const stateData& stateDataValue, const solverMode& sMode) +double AcBus::computeError(const stateData& stateDataValue, const SolverMode& sMode) { updateLocalCache(noInputs, stateDataValue, sMode); double err = 0; @@ -2278,7 +2278,7 @@ stringVec AcBus::localStateNames() const return stNames; } -void AcBus::setOffsets(const solverOffsets& newOffsets, const solverMode& sMode) +void AcBus::setOffsets(const solverOffsets& newOffsets, const SolverMode& sMode) { offsets.setOffsets(newOffsets, sMode); solverOffsets newLocalOffsets(newOffsets); @@ -2304,7 +2304,7 @@ void AcBus::setOffsets(const solverOffsets& newOffsets, const solverMode& sMode) } } -void AcBus::setOffset(index_t offset, const solverMode& sMode) +void AcBus::setOffset(index_t offset, const SolverMode& sMode) { for (auto* load : attachedLoads) { load->setOffset(offset, sMode); @@ -2328,7 +2328,7 @@ void AcBus::setOffset(index_t offset, const solverMode& sMode) } } -void AcBus::setRootOffset(index_t Roffset, const solverMode& sMode) +void AcBus::setRootOffset(index_t Roffset, const SolverMode& sMode) { offsets.setRootOffset(Roffset, sMode); auto& solverOffsetData = offsets.getOffsets(sMode); @@ -2371,7 +2371,7 @@ void AcBus::reconnect(GridBus* mapBus) } } } -bool AcBus::useAngle(const solverMode& sMode) const +bool AcBus::useAngle(const SolverMode& sMode) const { if ((hasAlgebraic(sMode)) && (isConnected())) { if (isDynamic(sMode)) { @@ -2385,7 +2385,7 @@ bool AcBus::useAngle(const solverMode& sMode) const return false; } -bool AcBus::useVoltage(const solverMode& sMode) const +bool AcBus::useVoltage(const SolverMode& sMode) const { if ((hasAlgebraic(sMode)) && (isConnected()) && (!isDC(sMode))) { if (isDynamic(sMode)) { @@ -2399,7 +2399,7 @@ bool AcBus::useVoltage(const solverMode& sMode) const return false; } -count_t AcBus::getDependencyCount(const solverMode& sMode) const +count_t AcBus::getDependencyCount(const SolverMode& sMode) const { count_t sum = 0; if (isDC(sMode)) { @@ -2429,7 +2429,7 @@ count_t AcBus::getDependencyCount(const solverMode& sMode) const return sum; } -stateSizes AcBus::localStateSizes(const solverMode& sMode) const +stateSizes AcBus::localStateSizes(const SolverMode& sMode) const { stateSizes busSS; if (hasAlgebraic(sMode)) { @@ -2455,7 +2455,7 @@ stateSizes AcBus::localStateSizes(const solverMode& sMode) const return busSS; } -count_t AcBus::localJacobianCount(const solverMode& sMode) const +count_t AcBus::localJacobianCount(const SolverMode& sMode) const { count_t totaljacSize = 0; if (hasAlgebraic(sMode)) { @@ -2472,7 +2472,7 @@ count_t AcBus::localJacobianCount(const solverMode& sMode) const return totaljacSize; } -int AcBus::getMode(const solverMode& sMode) const +int AcBus::getMode(const SolverMode& sMode) const { if (isDynamic(sMode)) { if (isDifferentialOnly(sMode)) { @@ -2537,7 +2537,7 @@ void AcBus::updateFlags(bool /*dynOnly*/) static const IOlocs inLoc{0, 1, 2}; -void AcBus::computeDerivatives(const stateData& stateDataValue, const solverMode& sMode) +void AcBus::computeDerivatives(const stateData& stateDataValue, const SolverMode& sMode) { if (!isConnected()) { return; @@ -2567,7 +2567,7 @@ void AcBus::computeDerivatives(const stateData& stateDataValue, const solverMode // computed power at bus void AcBus::updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) + const SolverMode& sMode) { if (!S.needsUpdate(stateDataValue)) { return; @@ -2701,7 +2701,7 @@ double AcBus::get(std::string_view param, unit unitType) const ChangeCode AcBus::rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { const double currentVoltage = getVoltage(stateDataValue, sMode); diff --git a/src/griddyn/primary/AcBus.h b/src/griddyn/primary/AcBus.h index ae54a8a65..34c1bbdcb 100644 --- a/src/griddyn/primary/AcBus.h +++ b/src/griddyn/primary/AcBus.h @@ -101,14 +101,14 @@ class AcBus: public GridBus { virtual void alert(CoreObject* obj, int code) override; // dynInitializeB - virtual void setOffsets(const solverOffsets& newOffsets, const solverMode& sMode) override; - virtual void setOffset(index_t offset, const solverMode& sMode) override; + virtual void setOffsets(const solverOffsets& newOffsets, const SolverMode& sMode) override; + virtual void setOffset(index_t offset, const SolverMode& sMode) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; - virtual void setRootOffset(index_t Roffset, const solverMode& sMode) override; + virtual void setRootOffset(index_t Roffset, const SolverMode& sMode) override; protected: virtual void pFlowObjectInitializeA(coreTime time0, std::uint32_t flags) override; @@ -150,28 +150,28 @@ class AcBus: public GridBus { const stateData& stateDataValue, matrixData& matrixDataValue, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& stateDataValue, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& stateDataValue, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; virtual void voltageUpdate(const stateData& stateDataValue, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; /** @brief try to shift the states to something more consistent called when the current states do not make a consistent condition, calling converge will @@ -188,7 +188,7 @@ class AcBus: public GridBus { virtual void converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode mode = ConvergeMode::high_error_only, double tol = 0.01) override; /** @brief try to shift the local states to something more valid @@ -200,13 +200,13 @@ class AcBus: public GridBus { @param[in] mode the mode of the convergence @param[in] tol the tolerance to converge to */ - virtual void localConverge(const solverMode& sMode, int mode = 0, double tol = 0.01); + virtual void localConverge(const SolverMode& sMode, int mode = 0, double tol = 0.01); /** @brief return the last error in the real power*/ virtual void updateLocalCache() override; virtual void updateLocalCache(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) override; + const SolverMode& sMode) override; protected: /** @brief compute adjustments required for the dynamic update*/ @@ -214,15 +214,15 @@ class AcBus: public GridBus { /** @brief compute the partial derivatives based on the given state data @param[in] stateDataValue the state Data in question @param[in] sMode the solver mode*/ - virtual void computeDerivatives(const stateData& stateDataValue, const solverMode& sMode); + virtual void computeDerivatives(const stateData& stateDataValue, const SolverMode& sMode); public: - void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; /** @brief a faster function to set the voltage and angle of a bus* @param[in] Vnew the new voltage @param[in] Anew the new angle @@ -230,9 +230,9 @@ class AcBus: public GridBus { virtual void setVoltageAngle(double Vnew, double Anew) override; // for identifying which variables are algebraic vs differential virtual void getVariableType(double sdata[], - const solverMode& sMode) override; // only applicable in DAE + const SolverMode& sMode) override; // only applicable in DAE // mode - virtual void getTols(double tols[], const solverMode& sMode) override; + virtual void getTols(double tols[], const SolverMode& sMode) override; // dynamic simulation virtual stringVec localStateNames() const override; @@ -292,63 +292,63 @@ class AcBus: public GridBus { virtual IOdata getOutputs(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode) const override; - virtual index_t getOutputLoc(const solverMode& sMode, index_t num) const override; + const SolverMode& sMode) const override; + virtual index_t getOutputLoc(const SolverMode& sMode, index_t num) const override; - virtual IOlocs getOutputLocs(const solverMode& sMode) const override; + virtual IOlocs getOutputLocs(const SolverMode& sMode) const override; /** @brief get the voltage * @param[in] state the system state - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the bus voltage **/ - virtual double getVoltage(const double state[], const solverMode& sMode) const override; + virtual double getVoltage(const double state[], const SolverMode& sMode) const override; /** @brief get the angle * @param[in] state the system state - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the bus angle **/ - virtual double getAngle(const double state[], const solverMode& sMode) const override; + virtual double getAngle(const double state[], const SolverMode& sMode) const override; /** @brief get the voltage * @param[in] stateDataValue the system state data - @param[in] sMode the corresponding solverMode to the state data + @param[in] sMode the corresponding SolverMode to the state data @return the bus voltage **/ virtual double getVoltage(const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; /** @brief get the angle * @param[in] stateDataValue the system state data - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the bus angle **/ virtual double getAngle(const stateData& stateDataValue, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; /** @brief get the bus frequency * @param[in] stateDataValue the system state data - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the bus frequency **/ - virtual double getFreq(const stateData& stateDataValue, const solverMode& sMode) const override; + virtual double getFreq(const stateData& stateDataValue, const SolverMode& sMode) const override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& stateDataValue, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; /** @brief function used for returning the mode of the bus depends on the interaction of the SolverInterface and the bus type - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return the system mode **/ - virtual int getMode(const solverMode& sMode) const; + virtual int getMode(const SolverMode& sMode) const; /** @brief function to determine there is a state representing the angle - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return true if there is an angle state false otherwise **/ - virtual bool useAngle(const solverMode& sMode) const; + virtual bool useAngle(const SolverMode& sMode) const; /** @brief function to determine there is a state representing the voltage - @param[in] sMode the corresponding solverMode to the state + @param[in] sMode the corresponding SolverMode to the state @return true if there is an voltage state false otherwise **/ - virtual bool useVoltage(const solverMode& sMode) const; + virtual bool useVoltage(const SolverMode& sMode) const; virtual void updateFlags(bool dynOnly = false) override; // for registering and removing power control objects @@ -373,20 +373,20 @@ class AcBus: public GridBus { protected: /** @brief compute the current power-balance error @param[in] stateDataValue the stateData from which to compute the error - @param[in] sMode the solverMode corresponding to the stateData + @param[in] sMode the SolverMode corresponding to the stateData @return the error in the power balance equations */ - virtual double computeError(const stateData& stateDataValue, const solverMode& sMode) override; + virtual double computeError(const stateData& stateDataValue, const SolverMode& sMode) override; private: void convergeHighErrorOnly(const stateData& stateDataValue, double state[], - const solverMode& sMode, + const SolverMode& sMode, double& err, double tol); bool convergeStrongIteration(const stateData& stateDataValue, double state[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode& mode, double& err, double& voltageValue, @@ -400,7 +400,7 @@ class AcBus: public GridBus { int& iteration); bool convergeVoltageOnly(const stateData& stateDataValue, double state[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode& mode, double& voltageValue, double angleValue, @@ -411,7 +411,7 @@ class AcBus: public GridBus { bool& forceVoltageUp, int& iteration); double getAverageAngle() const; - count_t getDependencyCount(const solverMode& sMode) const; + count_t getDependencyCount(const SolverMode& sMode) const; Generator* keyGen = nullptr; }; diff --git a/src/griddyn/primary/DcBus.cpp b/src/griddyn/primary/DcBus.cpp index 5784e57d5..710897e5c 100644 --- a/src/griddyn/primary/DcBus.cpp +++ b/src/griddyn/primary/DcBus.cpp @@ -61,7 +61,7 @@ void DcBus::pFlowObjectInitializeB() propogatePower(); } -stateSizes DcBus::localStateSizes(const solverMode& sMode) const +stateSizes DcBus::localStateSizes(const SolverMode& sMode) const { stateSizes busSS; if (hasAlgebraic(sMode)) { @@ -84,7 +84,7 @@ stateSizes DcBus::localStateSizes(const solverMode& sMode) const return busSS; } -count_t DcBus::localJacobianCount(const solverMode& sMode) const +count_t DcBus::localJacobianCount(const SolverMode& sMode) const { count_t localJacSize = 0; if (hasAlgebraic(sMode)) { @@ -190,7 +190,7 @@ void DcBus::dynObjectInitializeB(const IOdata& inputs, angle = 0; } -void DcBus::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void DcBus::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { GridBus::timestep(time, inputs, sMode); } @@ -255,7 +255,7 @@ void DcBus::set(std::string_view param, double val, unit unitType) } void DcBus::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { if (hasAlgebraic(sMode)) { @@ -281,7 +281,7 @@ void DcBus::getStateName(stringVec& stNames, void DcBus::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { auto Voffset = offsets.getVOffset(sMode); @@ -302,7 +302,7 @@ void DcBus::setState(coreTime time, GridBus::setState(time, state, dstate_dt, sMode); } -void DcBus::guessState(coreTime time, double state[], double dstate_dt[], const solverMode& sMode) +void DcBus::guessState(coreTime time, double state[], double dstate_dt[], const SolverMode& sMode) { auto Voffset = offsets.getVOffset(sMode); @@ -322,7 +322,7 @@ void DcBus::guessState(coreTime time, double state[], double dstate_dt[], const void DcBus::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { GridBus::residual(inputs, sD, resid, sMode); auto Voffset = offsets.getVOffset(sMode); @@ -341,7 +341,7 @@ void DcBus::residual(const IOdata& inputs, static const IOlocs inLoc{0, 1, 2}; -void DcBus::computeDerivatives(const stateData& sD, const solverMode& sMode) +void DcBus::computeDerivatives(const stateData& sD, const SolverMode& sMode) { matrixDataCompact<2, 3> partDeriv; if (!isConnected()) { @@ -376,7 +376,7 @@ void DcBus::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { auto inputs = getOutputs(noInputs, sD, sMode); @@ -433,14 +433,14 @@ void DcBus::jacobianElements(const IOdata& /*inputs*/, */ } -IOlocs DcBus::getOutputLocs(const solverMode& sMode) const +IOlocs DcBus::getOutputLocs(const SolverMode& sMode) const { return {useVoltage(sMode) ? offsets.getVOffset(sMode) : kNullLocation, kNullLocation, kNullLocation}; } -index_t DcBus::getOutputLoc(const solverMode& sMode, index_t num) const +index_t DcBus::getOutputLoc(const SolverMode& sMode, index_t num) const { if (num == voltageInLocation) { return useVoltage(sMode) ? offsets.getVOffset(sMode) : kNullLocation; @@ -452,15 +452,15 @@ index_t DcBus::getOutputLoc(const solverMode& sMode, index_t num) const void DcBus::converge(coreTime /*time*/, double /*state*/[], double /*dstate_dt*/[], - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, ConvergeMode /*mode*/, double /*tol*/) -// void DcBus::converge (const coreTime time, double state[], double dstate_dt[], const solverMode +// void DcBus::converge (const coreTime time, double state[], double dstate_dt[], const SolverMode // &sMode, double tol, int mode) { } -int DcBus::getMode(const solverMode& sMode) const +int DcBus::getMode(const SolverMode& sMode) const { if (isDynamic(sMode)) { if (isDifferentialOnly(sMode)) { @@ -471,7 +471,7 @@ int DcBus::getMode(const solverMode& sMode) const return (static_cast(type) | 1); } -double DcBus::getVoltage(const double state[], const solverMode& sMode) const +double DcBus::getVoltage(const double state[], const SolverMode& sMode) const { if (isLocal(sMode)) { return voltage; @@ -483,7 +483,7 @@ double DcBus::getVoltage(const double state[], const solverMode& sMode) const return voltage; } -double DcBus::getVoltage(const stateData& sD, const solverMode& sMode) const +double DcBus::getVoltage(const stateData& sD, const SolverMode& sMode) const { if (isLocal(sMode)) { return voltage; @@ -495,7 +495,7 @@ double DcBus::getVoltage(const stateData& sD, const solverMode& sMode) const return voltage; } -bool DcBus::useVoltage(const solverMode& sMode) const +bool DcBus::useVoltage(const SolverMode& sMode) const { bool ret = true; if (isDifferentialOnly(sMode)) { diff --git a/src/griddyn/primary/DcBus.h b/src/griddyn/primary/DcBus.h index c90b0d927..b1174fe64 100644 --- a/src/griddyn/primary/DcBus.h +++ b/src/griddyn/primary/DcBus.h @@ -49,9 +49,9 @@ class DcBus: public GridBus { // dynInitializeB - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; protected: virtual void pFlowObjectInitializeA(coreTime time0, std::uint32_t flags) override; @@ -79,46 +79,46 @@ class DcBus: public GridBus { virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; - void computeDerivatives(const stateData& sD, const solverMode& sMode); + void computeDerivatives(const stateData& sD, const SolverMode& sMode); virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode mode = ConvergeMode::local_iteration, double tol = 0.01) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; - virtual double getVoltage(const double state[], const solverMode& sMode) const override; + virtual double getVoltage(const double state[], const SolverMode& sMode) const override; - virtual double getVoltage(const stateData& sD, const solverMode& sMode) const override; + virtual double getVoltage(const stateData& sD, const SolverMode& sMode) const override; - virtual IOlocs getOutputLocs(const solverMode& sMode) const override; + virtual IOlocs getOutputLocs(const SolverMode& sMode) const override; - virtual index_t getOutputLoc(const solverMode& sMode, index_t num = 0) const override; + virtual index_t getOutputLoc(const SolverMode& sMode, index_t num = 0) const override; - virtual bool useVoltage(const solverMode& sMode) const; - virtual int getMode(const solverMode& sMode) const; + virtual bool useVoltage(const SolverMode& sMode) const; + virtual int getMode(const SolverMode& sMode) const; virtual int propogatePower(bool makeSlack = false) override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; protected: diff --git a/src/griddyn/primary/GridArea.cpp b/src/griddyn/primary/GridArea.cpp index bb88b8c1b..c4b3fd001 100644 --- a/src/griddyn/primary/GridArea.cpp +++ b/src/griddyn/primary/GridArea.cpp @@ -642,7 +642,7 @@ void GridArea::updateLocalCache() } } -void GridArea::updateLocalCache(const IOdata& inputs, const stateData& sD, const solverMode& sMode) +void GridArea::updateLocalCache(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) { // links should come first for (auto* link : m_Links) { @@ -777,7 +777,7 @@ void GridArea::updateTheta(coreTime /*time*/) {} void GridArea::converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode mode, double tol) { @@ -908,7 +908,7 @@ double GridArea::get(std::string_view param, unit unitType) const return (vali != 0) ? (static_cast(vali)) : val; } -void GridArea::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void GridArea::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { // update the tie lines first for (auto* gL : m_Links) { @@ -978,7 +978,7 @@ count_t GridArea::getVoltage(std::vector& voltages, index_t start) const count_t GridArea::getVoltage(std::vector& voltages, const double state[], - const solverMode& sMode, + const SolverMode& sMode, index_t start) const { count_t cnt = 0; @@ -1013,7 +1013,7 @@ count_t GridArea::getAngle(std::vector& angles, index_t start) const count_t GridArea::getAngle(std::vector& angles, const double state[], - const solverMode& sMode, + const SolverMode& sMode, index_t start) const { count_t cnt = 0; @@ -1045,7 +1045,7 @@ count_t GridArea::getFreq(std::vector& frequencies, index_t start) const } /* -count_t GridArea::getFreq(std::vector &F, const double state[], const solverMode &sMode, +count_t GridArea::getFreq(std::vector &F, const double state[], const SolverMode &sMode, index_t start) const { count_t cnt = 0; @@ -1349,7 +1349,7 @@ double GridArea::getAvgAngle() const return (a / cnt); } -double GridArea::getAvgAngle(const stateData& sD, const solverMode& sMode) const +double GridArea::getAvgAngle(const stateData& sD, const SolverMode& sMode) const { double a = 0.0; double cnt = 0.0; @@ -1382,7 +1382,7 @@ double GridArea::getAvgFreq() const void GridArea::guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { auto cobj = opObjectLists->begin(sMode); auto cend = opObjectLists->end(sMode); @@ -1393,7 +1393,7 @@ void GridArea::guessState(coreTime time, // next do any internal control elements } -void GridArea::getVariableType(double sdata[], const solverMode& sMode) +void GridArea::getVariableType(double sdata[], const SolverMode& sMode) { auto ra = opObjectLists->begin(sMode); auto rend = opObjectLists->end(sMode); @@ -1405,7 +1405,7 @@ void GridArea::getVariableType(double sdata[], const solverMode& sMode) // next do any internal area states } -void GridArea::getTols(double tols[], const solverMode& sMode) +void GridArea::getTols(double tols[], const SolverMode& sMode) { auto ra = opObjectLists->begin(sMode); auto rend = opObjectLists->end(sMode); @@ -1420,7 +1420,7 @@ void GridArea::getTols(double tols[], const solverMode& sMode) void GridArea::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { for (auto* ro : rootObjects) { ro->rootTest(inputs, sD, roots, sMode); @@ -1434,7 +1434,7 @@ void GridArea::rootTest(const IOdata& inputs, ChangeCode GridArea::rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { ChangeCode ret = ChangeCode::NO_CHANGE; @@ -1469,7 +1469,7 @@ ChangeCode GridArea::rootCheck(const IOdata& inputs, void GridArea::rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { auto RF = vecFindne(rootMask, 0); size_t cloc = 0; @@ -1514,7 +1514,7 @@ void GridArea::rootTrigger(coreTime time, void GridArea::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { prevTime = time; @@ -1543,7 +1543,7 @@ void GridArea::setState(coreTime time, // next do any internal area states } -void GridArea::getVoltageStates(double vStates[], const solverMode& sMode) const +void GridArea::getVoltageStates(double vStates[], const SolverMode& sMode) const { index_t Voffset; @@ -1573,7 +1573,7 @@ void GridArea::getVoltageStates(double vStates[], const solverMode& sMode) const } } -void GridArea::getAngleStates(double aStates[], const solverMode& sMode) const +void GridArea::getAngleStates(double aStates[], const SolverMode& sMode) const { index_t Aoffset; @@ -1605,7 +1605,7 @@ void GridArea::getAngleStates(double aStates[], const solverMode& sMode) const // residual -void GridArea::preEx(const IOdata& inputs, const stateData& sD, const solverMode& sMode) +void GridArea::preEx(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) { opObjectLists->preEx(inputs, sD, sMode); } @@ -1613,7 +1613,7 @@ void GridArea::preEx(const IOdata& inputs, const stateData& sD, const solverMode void GridArea::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { opObjectLists->residual(inputs, sD, resid, sMode); @@ -1623,7 +1623,7 @@ void GridArea::residual(const IOdata& inputs, void GridArea::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { opObjectLists->algebraicUpdate(inputs, sD, update, sMode, alpha); @@ -1632,7 +1632,7 @@ void GridArea::algebraicUpdate(const IOdata& inputs, } void GridArea::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { std::string prefix2; @@ -1652,7 +1652,7 @@ void GridArea::getStateName(stringVec& stNames, void GridArea::delayedResidual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { opObjectLists->delayedResidual(inputs, sD, resid, sMode); } @@ -1660,7 +1660,7 @@ void GridArea::delayedResidual(const IOdata& inputs, void GridArea::delayedDerivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { opObjectLists->delayedDerivative(inputs, sD, deriv, sMode); } @@ -1669,7 +1669,7 @@ void GridArea::delayedJacobian(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { opObjectLists->delayedJacobian(inputs, sD, md, inputLocs, sMode); } @@ -1677,7 +1677,7 @@ void GridArea::delayedJacobian(const IOdata& inputs, void GridArea::delayedAlgebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { opObjectLists->delayedAlgebraicUpdate(inputs, sD, update, sMode, alpha); @@ -1686,7 +1686,7 @@ void GridArea::delayedAlgebraicUpdate(const IOdata& inputs, void GridArea::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { opObjectLists->derivative(inputs, sD, deriv, sMode); // next do any internal states @@ -1697,7 +1697,7 @@ void GridArea::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { opObjectLists->jacobianElements(inputs, sD, md, inputLocs, sMode); // next do any internal control elements @@ -1718,7 +1718,7 @@ void GridArea::updateFlags(bool /*dynOnly*/) } } -void GridArea::setOffsets(const solverOffsets& newOffsets, const solverMode& sMode) +void GridArea::setOffsets(const solverOffsets& newOffsets, const SolverMode& sMode) { if (!(isStateCountLoaded(sMode))) { loadStateSizes(sMode); @@ -1733,7 +1733,7 @@ void GridArea::setOffsets(const solverOffsets& newOffsets, const solverMode& sMo } } -void GridArea::setOffset(index_t offset, const solverMode& sMode) +void GridArea::setOffset(index_t offset, const SolverMode& sMode) { if (!isEnabled()) { return; @@ -1745,7 +1745,7 @@ void GridArea::setOffset(index_t offset, const solverMode& sMode) offsets.setOffset(offset, sMode); } -void GridArea::setRootOffset(index_t Roffset, const solverMode& sMode) +void GridArea::setRootOffset(index_t Roffset, const SolverMode& sMode) { offsets.setRootOffset(Roffset, sMode); const auto& so = offsets.getOffsets(sMode); @@ -1761,7 +1761,7 @@ double GridArea::getTieFlowReal() const return (getGenerationReal() - getLoadReal() - getLoss()); } -double GridArea::getMasterAngle(const stateData& sD, const solverMode& sMode) const +double GridArea::getMasterAngle(const stateData& sD, const SolverMode& sMode) const { if (masterBus >= 0) { return m_Buses[masterBus]->getAngle(sD, sMode); @@ -1775,23 +1775,23 @@ double GridArea::getMasterAngle(const stateData& sD, const solverMode& sMode) co return 0.0; } -stateSizes GridArea::localStateSizes(const solverMode& /*sMode*/) const +stateSizes GridArea::localStateSizes(const SolverMode& /*sMode*/) const { return offsets.local().local; } -count_t GridArea::localJacobianCount(const solverMode& /*sMode*/) const +count_t GridArea::localJacobianCount(const SolverMode& /*sMode*/) const { return offsets.local().local.jacSize; } -std::pair GridArea::LocalRootCount(const solverMode& /*sMode*/) const +std::pair GridArea::LocalRootCount(const SolverMode& /*sMode*/) const { const auto& lc = offsets.local().local; return std::make_pair(lc.algRoots, lc.diffRoots); } -void GridArea::loadStateSizes(const solverMode& sMode) +void GridArea::loadStateSizes(const SolverMode& sMode) { if (isStateCountLoaded(sMode)) { return; @@ -1833,7 +1833,7 @@ void GridArea::loadStateSizes(const solverMode& sMode) opObjectLists->makeList(sMode, primaryObjects); } -void GridArea::loadRootSizes(const solverMode& sMode) +void GridArea::loadRootSizes(const SolverMode& sMode) { if (isRootCountLoaded(sMode)) { return; @@ -1872,7 +1872,7 @@ void GridArea::loadRootSizes(const solverMode& sMode) so.rootsLoaded = true; } -void GridArea::loadJacobianSizes(const solverMode& sMode) +void GridArea::loadJacobianSizes(const SolverMode& sMode) { if (isJacobianCountLoaded(sMode)) { return; diff --git a/src/griddyn/primary/GridBus.cpp b/src/griddyn/primary/GridBus.cpp index 1e022916b..1a1e1bc5e 100644 --- a/src/griddyn/primary/GridBus.cpp +++ b/src/griddyn/primary/GridBus.cpp @@ -320,7 +320,7 @@ void GridBus::pFlowObjectInitializeB() m_state = {voltage, angle, freq}; } -void GridBus::preEx(const IOdata& /*inputs*/, const stateData& sD, const solverMode& sMode) +void GridBus::preEx(const IOdata& /*inputs*/, const stateData& sD, const SolverMode& sMode) { auto inputs = getOutputs(noInputs, sD, sMode); GridComponent::preEx(inputs, sD, sMode); @@ -430,7 +430,7 @@ void GridBus::generationAdjust(double /*adjustment*/) // adjust the real power flow } -void GridBus::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& sMode) +void GridBus::timestep(coreTime time, const IOdata& /*inputs*/, const SolverMode& sMode) { auto inputs = getOutputs(noInputs, emptyStateData, sMode); GridComponent::timestep(time, inputs, sMode); @@ -598,7 +598,7 @@ void GridBus::setVoltageAngle(double Vnew, double Anew) IOdata GridBus::getOutputs(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { return ((sMode.local) || (sD.empty())) ? IOdata{voltage, angle, freq} : @@ -607,7 +607,7 @@ IOdata GridBus::getOutputs(const IOdata& /*inputs*/, static const IOlocs noLocs{kNullLocation, kNullLocation, kNullLocation}; -IOlocs GridBus::getOutputLocs(const solverMode& /*sMode*/) const +IOlocs GridBus::getOutputLocs(const SolverMode& /*sMode*/) const { return noLocs; } @@ -624,7 +624,7 @@ const IOlocs& GridBus::getOutputLocsRef() const double GridBus::getOutput(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outNum) const { switch (outNum) { @@ -653,22 +653,22 @@ double GridBus::getOutput(index_t outNum) const } } -double GridBus::getVoltage(const double /*state*/[], const solverMode& /*sMode*/) const +double GridBus::getVoltage(const double /*state*/[], const SolverMode& /*sMode*/) const { return voltage; } -double GridBus::getAngle(const double /*state*/[], const solverMode& /*sMode*/) const +double GridBus::getAngle(const double /*state*/[], const SolverMode& /*sMode*/) const { return angle; } -double GridBus::getVoltage(const stateData& /*sD*/, const solverMode& /*sMode*/) const +double GridBus::getVoltage(const stateData& /*sD*/, const SolverMode& /*sMode*/) const { return voltage; } -double GridBus::getAngle(const stateData& /*sD*/, const solverMode& /*sMode*/) const +double GridBus::getAngle(const stateData& /*sD*/, const SolverMode& /*sMode*/) const { return angle; } @@ -678,7 +678,7 @@ bool GridBus::hasInertialAngle() const return ((!attachedGens.empty()) && (isConnected())); } -double GridBus::getFreq(const stateData& /*sD*/, const solverMode& /*sMode*/) const +double GridBus::getFreq(const stateData& /*sD*/, const SolverMode& /*sMode*/) const { return freq; } @@ -890,7 +890,7 @@ int GridBus::propogatePower(bool /*makeSlack*/) void GridBus::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(inputs, sD, sMode); if ((opFlags[low_voltage_check_flag]) && (outputs[voltageInLocation] < Vtol / 2.0) && @@ -906,7 +906,7 @@ void GridBus::residual(const IOdata& inputs, void GridBus::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(inputs, sD, sMode); GridComponent::derivative(outputs, sD, deriv, sMode); @@ -919,7 +919,7 @@ void GridBus::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { updateLocalCache(inputs, sD, sMode); // import bus values (current theta and voltage) @@ -959,7 +959,7 @@ inline double dAcheck(double dT, double /*currA*/, double mxch = kPI / 8.0) void GridBus::voltageUpdate(const stateData& /*sD*/, double /*update*/[], - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, double /*alpha*/) { } @@ -967,7 +967,7 @@ void GridBus::voltageUpdate(const stateData& /*sD*/, void GridBus::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { if (algSize(sMode) == offsets.getOffsets(sMode).local.algSize) { @@ -981,13 +981,13 @@ void GridBus::algebraicUpdate(const IOdata& inputs, void GridBus::converge(coreTime /*time*/, double /*state*/[], double /*dstate_dt*/[], - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, ConvergeMode /*mode*/, double /*tol*/) { } -double GridBus::computeError(const stateData& sD, const solverMode& sMode) +double GridBus::computeError(const stateData& sD, const SolverMode& sMode) { updateLocalCache(noInputs, sD, sMode); @@ -1050,7 +1050,7 @@ static const IOlocs inLoc{0, 1, 2}; // computed power at bus void GridBus::updateLocalCache(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode) + const SolverMode& sMode) { if (!S.needsUpdate(sD)) { return; @@ -1394,7 +1394,7 @@ double GridBus::get(std::string_view param, unit unitType) const ChangeCode GridBus::rootCheck(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { auto inputs = getOutputs(noInputs, sD, sMode); @@ -1404,7 +1404,7 @@ ChangeCode GridBus::rootCheck(const IOdata& /*inputs*/, void GridBus::rootTest(const IOdata& /*inputs*/, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { auto inputs = getOutputs(noInputs, sD, sMode); GridComponent::rootTest(inputs, sD, roots, sMode); @@ -1413,7 +1413,7 @@ void GridBus::rootTest(const IOdata& /*inputs*/, void GridBus::rootTrigger(coreTime time, const IOdata& /*inputs*/, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { size_t rootCount = 0; int rootOffset = offsets.getRootOffset(sMode); diff --git a/src/griddyn/primary/InfiniteBus.cpp b/src/griddyn/primary/InfiniteBus.cpp index 7ff6eba1b..e1d0edf21 100644 --- a/src/griddyn/primary/InfiniteBus.cpp +++ b/src/griddyn/primary/InfiniteBus.cpp @@ -52,7 +52,7 @@ void infiniteBus::updateVoltageAngle(coreTime time) voltage += dvdt * dt; } -void infiniteBus::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void infiniteBus::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { updateVoltageAngle(time); GridBus::timestep(time, inputs, sMode); @@ -61,7 +61,7 @@ void infiniteBus::timestep(coreTime time, const IOdata& inputs, const solverMode void infiniteBus::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { updateVoltageAngle(time); GridBus::setState(time, state, dstate_dt, sMode); @@ -90,29 +90,29 @@ void infiniteBus::set(std::string_view param, double val, unit unitType) } } -double infiniteBus::getVoltage(const double /*state*/[], const solverMode& /*sMode*/) const +double infiniteBus::getVoltage(const double /*state*/[], const SolverMode& /*sMode*/) const { return voltage; } -double infiniteBus::getAngle(const double /*state*/[], const solverMode& /*sMode*/) const +double infiniteBus::getAngle(const double /*state*/[], const SolverMode& /*sMode*/) const { return angle; } -double infiniteBus::getVoltage(const stateData& sD, const solverMode& /*sMode*/) const +double infiniteBus::getVoltage(const stateData& sD, const SolverMode& /*sMode*/) const { const double dt = (!sD.empty()) ? static_cast(sD.time - prevTime) : 0.0; return voltage + dt * dvdt; } -double infiniteBus::getAngle(const stateData& sD, const solverMode& /*sMode*/) const +double infiniteBus::getAngle(const stateData& sD, const SolverMode& /*sMode*/) const { const double dt = (!sD.empty()) ? static_cast(sD.time - prevTime) : 0.0; return angle + 2 * kPI * (dt * ((freq - 1.0) + dfdt / 2)); } -double infiniteBus::getFreq(const stateData& sD, const solverMode& /*sMode*/) const +double infiniteBus::getFreq(const stateData& sD, const SolverMode& /*sMode*/) const { double dt = (!sD.empty()) ? static_cast(sD.time - prevTime) : 0.0; return freq + dt * dfdt; diff --git a/src/griddyn/primary/InfiniteBus.h b/src/griddyn/primary/InfiniteBus.h index 145db9119..98f7a0970 100644 --- a/src/griddyn/primary/InfiniteBus.h +++ b/src/griddyn/primary/InfiniteBus.h @@ -34,11 +34,11 @@ class infiniteBus: public GridBus { infiniteBus(double startVoltage, double startAngle, const std::string& objName = "infbus_$"); virtual CoreObject* clone(CoreObject* obj = nullptr) const override; // add components - void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void set(std::string_view param, std::string_view val) override; virtual void @@ -46,11 +46,11 @@ class infiniteBus: public GridBus { virtual bool checkCapable() override; - virtual double getVoltage(const double state[], const solverMode& sMode) const override; - virtual double getAngle(const double state[], const solverMode& sMode) const override; - virtual double getVoltage(const stateData& sD, const solverMode& sMode) const override; - virtual double getAngle(const stateData& sD, const solverMode& sMode) const override; - virtual double getFreq(const stateData& sD, const solverMode& sMode) const override; + virtual double getVoltage(const double state[], const SolverMode& sMode) const override; + virtual double getAngle(const double state[], const SolverMode& sMode) const override; + virtual double getVoltage(const stateData& sD, const SolverMode& sMode) const override; + virtual double getAngle(const stateData& sD, const SolverMode& sMode) const override; + virtual double getFreq(const stateData& sD, const SolverMode& sMode) const override; protected: /** update the Voltage and Angle based on time using the defined ramp rates*/ diff --git a/src/griddyn/primary/ListMaintainer.cpp b/src/griddyn/primary/ListMaintainer.cpp index 4257742c4..d61dd3403 100644 --- a/src/griddyn/primary/ListMaintainer.cpp +++ b/src/griddyn/primary/ListMaintainer.cpp @@ -11,14 +11,14 @@ #include namespace griddyn { -void fillList(const solverMode& sMode, +void fillList(const SolverMode& sMode, std::vector& list, std::vector& partlist, const std::vector& possObjs); listMaintainer::listMaintainer(): objectLists(4), partialLists(4), sModeLists(4) {} -void listMaintainer::makeList(const solverMode& sMode, const std::vector& possObjs) +void listMaintainer::makeList(const SolverMode& sMode, const std::vector& possObjs) { if (sMode.offsetIndex >= static_cast(objectLists.size())) { objectLists.resize(sMode.offsetIndex + 1); @@ -34,7 +34,7 @@ void listMaintainer::makeList(const solverMode& sMode, const std::vector& possObjs) +void listMaintainer::appendList(const SolverMode& sMode, const std::vector& possObjs) { if (sMode.offsetIndex >= static_cast(objectLists.size())) { objectLists.resize(sMode.offsetIndex + 1); @@ -47,7 +47,7 @@ void listMaintainer::appendList(const solverMode& sMode, const std::vector& list, std::vector& partlist, const std::vector& possObjs) @@ -77,7 +77,7 @@ void listMaintainer::makePreList(const std::vector& possObjs) } } -void listMaintainer::preEx(const IOdata& inputs, const stateData& sD, const solverMode& sMode) +void listMaintainer::preEx(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) { for (auto& obj : preExObjs) { obj->preEx(inputs, sD, sMode); @@ -88,7 +88,7 @@ void listMaintainer::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { if (!isListValid(sMode)) { return; @@ -117,7 +117,7 @@ void listMaintainer::jacobianElements(const IOdata& inputs, void listMaintainer::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (!isListValid(sMode)) { return; @@ -147,7 +147,7 @@ void listMaintainer::residual(const IOdata& inputs, void listMaintainer::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { if (!isListValid(sMode)) { @@ -178,7 +178,7 @@ void listMaintainer::algebraicUpdate(const IOdata& inputs, void listMaintainer::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { if (!isListValid(sMode)) { return; @@ -207,7 +207,7 @@ void listMaintainer::derivative(const IOdata& inputs, void listMaintainer::delayedResidual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { for (auto& obj : preExObjs) { obj->delayedResidual(inputs, sD, resid, sMode); @@ -216,7 +216,7 @@ void listMaintainer::delayedResidual(const IOdata& inputs, void listMaintainer::delayedDerivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { for (auto& obj : preExObjs) { obj->delayedDerivative(inputs, sD, deriv, sMode); @@ -227,7 +227,7 @@ void listMaintainer::delayedJacobian(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { for (auto& obj : preExObjs) { obj->delayedJacobian(inputs, sD, md, inputLocs, sMode); @@ -237,7 +237,7 @@ void listMaintainer::delayedJacobian(const IOdata& inputs, void listMaintainer::delayedAlgebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { for (auto& obj : preExObjs) { @@ -245,7 +245,7 @@ void listMaintainer::delayedAlgebraicUpdate(const IOdata& inputs, } } -bool listMaintainer::isListValid(const solverMode& sMode) const +bool listMaintainer::isListValid(const SolverMode& sMode) const { if (isValidIndex(sMode.offsetIndex, objectLists)) { return (sModeLists[sMode.offsetIndex].offsetIndex != kNullLocation); @@ -253,21 +253,21 @@ bool listMaintainer::isListValid(const solverMode& sMode) const return false; } -void listMaintainer::invalidate(const solverMode& sMode) +void listMaintainer::invalidate(const SolverMode& sMode) { if (isValidIndex(sMode.offsetIndex, objectLists)) { - sModeLists[sMode.offsetIndex] = solverMode(); + sModeLists[sMode.offsetIndex] = SolverMode(); } } void listMaintainer::invalidate() { for (auto& sml : sModeLists) { - sml = solverMode(); + sml = SolverMode(); } } -decltype(listMaintainer::objectLists[0].begin()) listMaintainer::begin(const solverMode& sMode) +decltype(listMaintainer::objectLists[0].begin()) listMaintainer::begin(const SolverMode& sMode) { if (isListValid(sMode)) { return objectLists[sMode.offsetIndex].begin(); @@ -275,7 +275,7 @@ decltype(listMaintainer::objectLists[0].begin()) listMaintainer::begin(const sol return objectLists[0].end(); } -decltype(listMaintainer::objectLists[0].end()) listMaintainer::end(const solverMode& sMode) +decltype(listMaintainer::objectLists[0].end()) listMaintainer::end(const SolverMode& sMode) { if (isListValid(sMode)) { return objectLists[sMode.offsetIndex].end(); @@ -284,7 +284,7 @@ decltype(listMaintainer::objectLists[0].end()) listMaintainer::end(const solverM } decltype(listMaintainer::objectLists[0].cbegin()) - listMaintainer::cbegin(const solverMode& sMode) const + listMaintainer::cbegin(const SolverMode& sMode) const { if (isListValid(sMode)) { return objectLists[sMode.offsetIndex].cbegin(); @@ -292,7 +292,7 @@ decltype(listMaintainer::objectLists[0].cbegin()) return objectLists[0].cend(); } -decltype(listMaintainer::objectLists[0].cend()) listMaintainer::cend(const solverMode& sMode) const +decltype(listMaintainer::objectLists[0].cend()) listMaintainer::cend(const SolverMode& sMode) const { if (isListValid(sMode)) { return objectLists[sMode.offsetIndex].cend(); @@ -300,7 +300,7 @@ decltype(listMaintainer::objectLists[0].cend()) listMaintainer::cend(const solve return objectLists[0].cend(); } -decltype(listMaintainer::objectLists[0].rbegin()) listMaintainer::rbegin(const solverMode& sMode) +decltype(listMaintainer::objectLists[0].rbegin()) listMaintainer::rbegin(const SolverMode& sMode) { if (isListValid(sMode)) { return objectLists[sMode.offsetIndex].rbegin(); @@ -308,7 +308,7 @@ decltype(listMaintainer::objectLists[0].rbegin()) listMaintainer::rbegin(const s return objectLists[0].rend(); } -decltype(listMaintainer::objectLists[0].rend()) listMaintainer::rend(const solverMode& sMode) +decltype(listMaintainer::objectLists[0].rend()) listMaintainer::rend(const SolverMode& sMode) { if (isListValid(sMode)) { return objectLists[sMode.offsetIndex].rend(); diff --git a/src/griddyn/primary/ListMaintainer.h b/src/griddyn/primary/ListMaintainer.h index bc4d21784..efcfb1932 100644 --- a/src/griddyn/primary/ListMaintainer.h +++ b/src/griddyn/primary/ListMaintainer.h @@ -31,76 +31,76 @@ class listMaintainer { objectLists; //!< lists of all the objects with states in a certain mode std::vector> partialLists; //!< list of all the non preEx object with states in a certain mode - std::vector sModeLists; //!< the list of solverModes relevant to each list + std::vector sModeLists; //!< the list of solverModes relevant to each list public: listMaintainer(); /** generate a list of the object that requires a preEx call*/ void makePreList(const std::vector& possObjs); /** make the list of objects for a certain mode*/ - void makeList(const solverMode& sMode, const std::vector& possObjs); + void makeList(const SolverMode& sMode, const std::vector& possObjs); /** append a set of objects to preexisting lists*/ - void appendList(const solverMode& sMode, const std::vector& possObjs); + void appendList(const SolverMode& sMode, const std::vector& possObjs); void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode); - void preEx(const IOdata& inputs, const stateData& sD, const solverMode& sMode); + const SolverMode& sMode); + void preEx(const IOdata& inputs, const stateData& sD, const SolverMode& sMode); void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode); + const SolverMode& sMode); void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha); void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode); + const SolverMode& sMode); void delayedResidual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode); + const SolverMode& sMode); void delayedDerivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode); + const SolverMode& sMode); void delayedJacobian(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode); + const SolverMode& sMode); void delayedAlgebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha); /** check if a list is valid*/ - bool isListValid(const solverMode& sMode) const; - void invalidate(const solverMode& sMode); + bool isListValid(const SolverMode& sMode) const; + void invalidate(const SolverMode& sMode); void invalidate(); - /** get a const iterator for the beginning of a list of particular solverMode*/ - decltype(objectLists[0].cbegin()) cbegin(const solverMode& sMode) const; - /** get a const iterator for the end of a list of particular solverMode*/ - decltype(objectLists[0].cbegin()) cend(const solverMode& sMode) const; + /** get a const iterator for the beginning of a list of particular SolverMode*/ + decltype(objectLists[0].cbegin()) cbegin(const SolverMode& sMode) const; + /** get a const iterator for the end of a list of particular SolverMode*/ + decltype(objectLists[0].cbegin()) cend(const SolverMode& sMode) const; - /** get an iterator for the beginning of a list of particular solverMode*/ - decltype(objectLists[0].begin()) begin(const solverMode& sMode); + /** get an iterator for the beginning of a list of particular SolverMode*/ + decltype(objectLists[0].begin()) begin(const SolverMode& sMode); - /** get an iterator for the end of a list of particular solverMode*/ - decltype(objectLists[0].begin()) end(const solverMode& sMode); + /** get an iterator for the end of a list of particular SolverMode*/ + decltype(objectLists[0].begin()) end(const SolverMode& sMode); - /** get a reverse iterator for the beginning of a list of particular solverMode*/ - decltype(objectLists[0].rbegin()) rbegin(const solverMode& sMode); - /** get a reverse iterator for the end of a list of particular solverMode*/ - decltype(objectLists[0].rbegin()) rend(const solverMode& sMode); + /** get a reverse iterator for the beginning of a list of particular SolverMode*/ + decltype(objectLists[0].rbegin()) rbegin(const SolverMode& sMode); + /** get a reverse iterator for the end of a list of particular SolverMode*/ + decltype(objectLists[0].rbegin()) rend(const SolverMode& sMode); }; } // namespace griddyn diff --git a/src/griddyn/relays/Breaker.cpp b/src/griddyn/relays/Breaker.cpp index 8610fe9a9..1462afe11 100644 --- a/src/griddyn/relays/Breaker.cpp +++ b/src/griddyn/relays/Breaker.cpp @@ -136,7 +136,7 @@ void breaker::dynObjectInitializeA(coreTime time0, std::uint32_t flags) auto ctiStateGrabber = std::make_unique(this); ctiStateGrabber->setGrabberFunction( - [](CoreObject* obj, const stateData& stateDataRef, const solverMode& sMode) -> double { + [](CoreObject* obj, const stateData& stateDataRef, const SolverMode& sMode) -> double { return stateDataRef.state[static_cast(obj)->offsets.getDiffOffset(sMode)]; }); @@ -214,7 +214,7 @@ void breaker::updateA(coreTime time) lastUpdateTime = time; } -stateSizes breaker::localStateSizes(const solverMode& sMode) const +stateSizes breaker::localStateSizes(const SolverMode& sMode) const { stateSizes stateSizeSet; if ((!isAlgebraicOnly(sMode)) && (mRecloserTap > 0)) { @@ -223,7 +223,7 @@ stateSizes breaker::localStateSizes(const solverMode& sMode) const return stateSizeSet; } -count_t breaker::localJacobianCount(const solverMode& sMode) const +count_t breaker::localJacobianCount(const SolverMode& sMode) const { if ((!isAlgebraicOnly(sMode)) && (mRecloserTap > 0)) { return 12; @@ -231,7 +231,7 @@ count_t breaker::localJacobianCount(const solverMode& sMode) const return 0; } -void breaker::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void breaker::timestep(coreTime time, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { prevTime = time; if (mLimit < kBigNum / 2.0) { @@ -248,7 +248,7 @@ void breaker::jacobianElements(const IOdata& /*inputs*/, const stateData& stateDataRef, matrixData& jacobian, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if (mUseCti) { matrixDataSparse localJacobian; @@ -315,7 +315,7 @@ void breaker::jacobianElements(const IOdata& /*inputs*/, void breaker::setState(coreTime time, const double state[], const double /*dstate_dt*/[], - const solverMode& sMode) + const SolverMode& sMode) { if (mUseCti) { auto offset = offsets.getDiffOffset(sMode); @@ -327,7 +327,7 @@ void breaker::setState(coreTime time, void breaker::residual(const IOdata& /*inputs*/, const stateData& stateDataRef, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (mUseCti) { auto offset = offsets.getDiffOffset(sMode); @@ -356,7 +356,7 @@ void breaker::residual(const IOdata& /*inputs*/, void breaker::guessState(const coreTime /*time*/, double state[], double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { if (mUseCti) { auto offset = offsets.getDiffOffset(sMode); @@ -378,7 +378,7 @@ void breaker::guessState(const coreTime /*time*/, } void breaker::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { if (stateSize(sMode) > 0) { @@ -420,7 +420,7 @@ void breaker::resetBreaker(coreTime time) alert(this, BREAKER_RECLOSE); logging::normal(this, "breaker {} reset on {}", m_terminal, m_sourceObject->getName()); opFlags.reset(BREAKER_TRIPPED_FLAG); - // timestep (time, solverMode::pFlow); + // timestep (time, SolverMode::pFlow); triggerAction(1); // reclose the breaker nextUpdateTime = maxTime; if (!opFlags[NONLINK_SOURCE_FLAG]) { // do a recompute power diff --git a/src/griddyn/relays/Breaker.h b/src/griddyn/relays/Breaker.h index 7b4f87b0c..4069f4cfe 100644 --- a/src/griddyn/relays/Breaker.h +++ b/src/griddyn/relays/Breaker.h @@ -56,30 +56,30 @@ class breaker: public Relay { virtual void updateA(coreTime time) override; // dynamic state functions - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& stateDataRef, matrixData& jacobian, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& stateDataRef, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + const SolverMode& sMode) override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; protected: diff --git a/src/griddyn/relays/Fuse.cpp b/src/griddyn/relays/Fuse.cpp index f46411bcb..50b63da6b 100644 --- a/src/griddyn/relays/Fuse.cpp +++ b/src/griddyn/relays/Fuse.cpp @@ -115,7 +115,7 @@ void fuse::dynObjectInitializeA(coreTime time0, std::uint32_t flags) auto cgst = std::make_unique(this); cgst->setGrabberFunction( - [](CoreObject* obj, const stateData& sD, const solverMode& sMode) -> double { + [](CoreObject* obj, const stateData& sD, const SolverMode& sMode) -> double { return sD.state[static_cast(obj)->offsets.getDiffOffset(sMode)]; }); @@ -206,7 +206,7 @@ ChangeCode fuse::setupFuseEvaluation() return ChangeCode::JACOBIAN_CHANGE; } -stateSizes fuse::localStateSizes(const solverMode& sMode) const +stateSizes fuse::localStateSizes(const SolverMode& sMode) const { stateSizes SS; if ((!isAlgebraicOnly(sMode)) && (mp_I2T > 0.0)) { @@ -215,7 +215,7 @@ stateSizes fuse::localStateSizes(const solverMode& sMode) const return SS; } -count_t fuse::localJacobianCount(const solverMode& sMode) const +count_t fuse::localJacobianCount(const SolverMode& sMode) const { if ((!isAlgebraicOnly(sMode)) && (mp_I2T > 0.0)) { return 12; @@ -223,7 +223,7 @@ count_t fuse::localJacobianCount(const solverMode& sMode) const return 0; } -void fuse::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void fuse::timestep(coreTime time, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { if (limit < kBigNum / 2.0) { double val = getConditionValue(0); @@ -239,7 +239,7 @@ void fuse::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& / void fuse::converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode /*mode*/, double /*tol*/) { @@ -250,7 +250,7 @@ void fuse::jacobianElements(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { // TODO(phlpt): Replace matrixDataSparse here with a translation matrix. if (useI2T) { @@ -303,7 +303,7 @@ void fuse::jacobianElements(const IOdata& /*inputs*/, void fuse::setState(coreTime time, const double state[], const double /*dstate_dt*/[], - const solverMode& sMode) + const SolverMode& sMode) { if (stateSize(sMode) > 0) { auto offset = offsets.getDiffOffset(sMode); @@ -320,7 +320,7 @@ double fuse::I2Tequation(double current) void fuse::residual(const IOdata& /*inputs*/, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (useI2T) { auto offset = offsets.getDiffOffset(sMode); @@ -347,7 +347,7 @@ void fuse::residual(const IOdata& /*inputs*/, void fuse::guessState(const coreTime /*time*/, double state[], double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { if (useI2T) { auto offset = offsets.getDiffOffset(sMode); @@ -363,7 +363,7 @@ void fuse::guessState(const coreTime /*time*/, } void fuse::getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const { if (stateSize(sMode) > 0) { diff --git a/src/griddyn/relays/Fuse.h b/src/griddyn/relays/Fuse.h index 8355363cb..ca27e5624 100644 --- a/src/griddyn/relays/Fuse.h +++ b/src/griddyn/relays/Fuse.h @@ -46,36 +46,36 @@ class fuse: public Relay { virtual void dynObjectInitializeA(coreTime time0, std::uint32_t flags) override; // dynamic functions for evaluation with a limit exceeded - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void guessState(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void converge(coreTime time, double state[], double dstate_dt[], - const solverMode& sMode, + const SolverMode& sMode, ConvergeMode = ConvergeMode::high_error_only, double tol = 0.01) override; - virtual stateSizes localStateSizes(const solverMode& sMode) const override; + virtual stateSizes localStateSizes(const SolverMode& sMode) const override; - virtual count_t localJacobianCount(const solverMode& sMode) const override; + virtual count_t localJacobianCount(const SolverMode& sMode) const override; virtual void getStateName(stringVec& stNames, - const solverMode& sMode, + const SolverMode& sMode, const std::string& prefix) const override; protected: diff --git a/src/griddyn/relays/Relay.cpp b/src/griddyn/relays/Relay.cpp index 8444097c8..15bbf74de 100644 --- a/src/griddyn/relays/Relay.cpp +++ b/src/griddyn/relays/Relay.cpp @@ -232,7 +232,7 @@ double Relay::getConditionValue(index_t conditionNumber) const double Relay::getConditionValue(index_t conditionNumber, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { if (isValidIndex(conditionNumber, conditions)) { return conditions[conditionNumber]->getVal(1, sD, sMode); @@ -622,7 +622,7 @@ ChangeCode void Relay::rootTest(const IOdata& /*inputs*/, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { auto ro = offsets.getRootOffset(sMode); for (auto condNum : conditionsWithRoots) { @@ -634,7 +634,7 @@ void Relay::rootTest(const IOdata& /*inputs*/, void Relay::rootTrigger(coreTime time, const IOdata& /*inputs*/, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { auto ro = offsets.getRootOffset(sMode); // Because conditionsWithRoots can change on a condition Trigger leading to an actionTaken @@ -662,7 +662,7 @@ void Relay::rootTrigger(coreTime time, ChangeCode Relay::rootCheck(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, CheckLevel /*level*/) { auto prevTrig = triggerCount; diff --git a/src/griddyn/relays/Sensor.cpp b/src/griddyn/relays/Sensor.cpp index d22147d45..0a43c5b48 100644 --- a/src/griddyn/relays/Sensor.cpp +++ b/src/griddyn/relays/Sensor.cpp @@ -468,7 +468,7 @@ void sensor::receiveMessage(std::uint64_t sourceID, std::shared_ptr static const IOdata kNullVec; double - sensor::getBlockOutput(const stateData& sD, const solverMode& sMode, index_t blockNumber) const + sensor::getBlockOutput(const stateData& sD, const SolverMode& sMode, index_t blockNumber) const { double ret = kNullVal; if (isLocal(sMode)) { @@ -484,7 +484,7 @@ double } double sensor::getBlockDerivOutput(const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t blockNumber) const { double ret = kNullVal; @@ -500,7 +500,7 @@ double sensor::getBlockDerivOutput(const stateData& sD, return ret; } -double sensor::getInput(const stateData& sD, const solverMode& sMode, index_t inputNumber) const +double sensor::getInput(const stateData& sD, const SolverMode& sMode, index_t inputNumber) const { double ret = kNullVal; if (isLocal(sMode)) { @@ -653,7 +653,7 @@ void sensor::updateA(coreTime time) Relay::updateA(time); } -void sensor::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void sensor::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { auto blks = static_cast(filterBlocks.size()); for (index_t kk = 0; kk < blks; ++kk) { @@ -668,7 +668,7 @@ void sensor::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if (stateSize(sMode) > 0) { matrixDataSparse d2, dp; @@ -697,7 +697,7 @@ void sensor::jacobianElements(const IOdata& inputs, void sensor::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { if (stateSize(sMode) > 0) { auto blks = static_cast(filterBlocks.size()); @@ -713,7 +713,7 @@ void sensor::residual(const IOdata& inputs, void sensor::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double /*alpha*/) { if (algSize(sMode) > 0) { @@ -729,7 +729,7 @@ void sensor::algebraicUpdate(const IOdata& inputs, void sensor::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { if (diffSize(sMode) > 0) { auto blks = static_cast(filterBlocks.size()); @@ -744,7 +744,7 @@ void sensor::derivative(const IOdata& inputs, double sensor::getBlockInput(index_t blockNum, const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { double res = dataSources[blockInputs[blockNum]]->grabData(sD, sMode); return res; @@ -765,7 +765,7 @@ const std::vector& sensor::outputNames() const return outputStrings; } -IOdata sensor::getOutputs(const IOdata& inputs, const stateData& sD, const solverMode& sMode) const +IOdata sensor::getOutputs(const IOdata& inputs, const stateData& sD, const SolverMode& sMode) const { IOdata out(m_outputSize); for (index_t pp = 0; pp < m_outputSize; ++pp) { @@ -776,7 +776,7 @@ IOdata sensor::getOutputs(const IOdata& inputs, const stateData& sD, const solve double sensor::getOutput(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outNum) const { if (!isValidIndex(outNum, outputMode)) { @@ -823,7 +823,7 @@ double sensor::getOutput(index_t outNum) const return out; } -index_t sensor::getOutputLoc(const solverMode& sMode, index_t outNum) const +index_t sensor::getOutputLoc(const SolverMode& sMode, index_t outNum) const { if (!isValidIndex(outNum, outputMode)) { return kNullLocation; @@ -842,7 +842,7 @@ index_t sensor::getOutputLoc(const solverMode& sMode, index_t outNum) const void sensor::outputPartialDerivatives(const IOdata& /*inputs*/, const stateData& sD, matrixData& md, - const solverMode& sMode) + const SolverMode& sMode) { matrixDataTranslate<3, double> aDT(md); for (index_t pp = 0; pp < static_cast(outputs.size()); ++pp) { @@ -867,7 +867,7 @@ void sensor::outputPartialDerivatives(const IOdata& /*inputs*/, void sensor::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { Relay::rootTest(inputs, sD, roots, sMode); if (stateSize(sMode) > 0) { @@ -887,7 +887,7 @@ void sensor::rootTest(const IOdata& inputs, void sensor::rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { Relay::rootTrigger(time, inputs, rootMask, sMode); if (stateSize(sMode) > 0) { @@ -906,7 +906,7 @@ void sensor::rootTrigger(coreTime time, ChangeCode sensor::rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { ChangeCode ret = Relay::rootCheck(inputs, sD, sMode, level); diff --git a/src/griddyn/relays/Sensor.h b/src/griddyn/relays/Sensor.h index c81cce87a..efdef631e 100644 --- a/src/griddyn/relays/Sensor.h +++ b/src/griddyn/relays/Sensor.h @@ -106,79 +106,79 @@ class sensor: public Relay { std::shared_ptr getGrabberSet(index_t grabberNum); // dynamic functions for evaluation with a limit exceeded - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outNum = 0) const override; virtual double getOutput(index_t outNum = 0) const override; - virtual index_t getOutputLoc(const solverMode& sMode, index_t outNum) const override; + virtual index_t getOutputLoc(const SolverMode& sMode, index_t outNum) const override; virtual IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; /** @brief get the block output from the sensor @param[in] sD the state data to get the output from - @param[in] sMode the solverMode corresponding to the data + @param[in] sMode the SolverMode corresponding to the data @param[in] blockNumber the number of the block to get the output from @return a double with the requested block output */ - double getBlockOutput(const stateData& sD, const solverMode& sMode, index_t blockNumber) const; + double getBlockOutput(const stateData& sD, const SolverMode& sMode, index_t blockNumber) const; /** @brief get the block rate of change from the sensor @param[in] sD the state data to get the output from - @param[in] sMode the solverMode corresponding to the data + @param[in] sMode the SolverMode corresponding to the data @param[in] blockNumber the number of the block to get the output from @return a double with the requested block output rate of change */ double getBlockDerivOutput(const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t blockNumber) const; /** @brief get the raw sensor input @param[in] sD the state data to get the output from - @param[in] sMode the solverMode corresponding to the data + @param[in] sMode the SolverMode corresponding to the data @param[in] inputNumber the input of the index to get the value @return a double with the requested raw input */ - double getInput(const stateData& sD, const solverMode& sMode, index_t inputNumber = 0) const; + double getInput(const stateData& sD, const SolverMode& sMode, index_t inputNumber = 0) const; virtual void updateA(coreTime time) override; virtual void outputPartialDerivatives(const IOdata& inputs, const stateData& sD, matrixData& md, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; virtual void receiveMessage(std::uint64_t sourceID, @@ -203,7 +203,7 @@ class sensor: public Relay { double getBlockInput(index_t blockNum, const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const; + const SolverMode& sMode) const; /** get the input to a block based on inputs only*/ double getBlockInput(index_t blockNum, const IOdata& inputs) const; }; diff --git a/src/griddyn/simulation/Diagnostics.cpp b/src/griddyn/simulation/Diagnostics.cpp index 2d96eb124..90b3565c4 100644 --- a/src/griddyn/simulation/Diagnostics.cpp +++ b/src/griddyn/simulation/Diagnostics.cpp @@ -23,7 +23,7 @@ // NOLINTBEGIN namespace griddyn { -std::pair checkResid(GridDynSimulation* gds, coreTime time, const solverMode& sMode) +std::pair checkResid(GridDynSimulation* gds, coreTime time, const SolverMode& sMode) { return checkResid(gds, time, gds->getSolverInterface(sMode)); } @@ -37,7 +37,7 @@ std::pair checkResid(GridDynSimulation* gds, std::pair checkResid(GridDynSimulation* gds, coreTime time, const std::shared_ptr& sd) { - const solverMode& sMode = sd->getSolverMode(); + const SolverMode& sMode = sd->getSolverMode(); std::vector resid; double* dstate_dt = nullptr; auto kSize = sd->size(); @@ -67,7 +67,7 @@ std::pair } int jacobianCheck(GridDynSimulation* gds, - const solverMode& queryMode, + const SolverMode& queryMode, double jacTol, bool useStateNames) { @@ -80,7 +80,7 @@ int jacobianCheck(GridDynSimulation* gds, } int errors = 0; auto sd = gds->getSolverInterface(queryMode); - const solverMode& sMode = sd->getSolverMode(); + const SolverMode& sMode = sd->getSolverMode(); gds->getSolverReady(sd); auto nsize = sd->size(); @@ -295,7 +295,7 @@ int jacobianCheck(GridDynSimulation* gds, } int residualCheck(GridDynSimulation* gds, - const solverMode& sMode, + const SolverMode& sMode, double residTol, bool useStateNames) { @@ -304,7 +304,7 @@ int residualCheck(GridDynSimulation* gds, int residualCheck(GridDynSimulation* gds, coreTime time, - const solverMode& sMode, + const SolverMode& sMode, double residTol, bool useStateNames) { @@ -357,7 +357,7 @@ int residualCheck(GridDynSimulation* gds, int algebraicCheck(GridDynSimulation* gds, coreTime time, - const solverMode& sMode, + const SolverMode& sMode, double algTol, bool useStateNames) { @@ -422,7 +422,7 @@ int algebraicCheck(GridDynSimulation* gds, int derivativeCheck(GridDynSimulation* gds, coreTime time, - const solverMode& sMode, + const SolverMode& sMode, double derivTol, bool useStateNames) { @@ -480,7 +480,7 @@ int derivativeCheck(GridDynSimulation* gds, } void dynamicSolverConvergenceTest(GridDynSimulation* gds, - const solverMode& sMode, + const SolverMode& sMode, const std::string& file, count_t pts, int mode) @@ -524,7 +524,7 @@ void dynamicSolverConvergenceTest(GridDynSimulation* gds, std::copy(state, state + ssize, tempState.begin()); int retval = sd->calcIC(gds->getSimulationTime(), 0.001, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); if (retval < 0) { double rval2 = retval; @@ -563,7 +563,7 @@ void dynamicSolverConvergenceTest(GridDynSimulation* gds, std::copy(state, state + ssize, tempState.begin()); int retval = sd->calcIC(gds->getSimulationTime(), 0.001, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); if (retval < 0) { double rval2 = retval; @@ -587,7 +587,7 @@ void dynamicSolverConvergenceTest(GridDynSimulation* gds, std::copy(state, state + ssize, tempState.begin()); int retval = sd->calcIC(gds->getSimulationTime(), 0.001, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); if (retval < 0) { double rval2 = retval; @@ -612,7 +612,7 @@ void dynamicSolverConvergenceTest(GridDynSimulation* gds, std::copy(state, state + ssize, tempState.begin()); sd->calcIC(gds->getSimulationTime(), 0.001, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); std::copy(tempState.begin(), tempState.begin() + ssize, state); } @@ -637,7 +637,7 @@ std::vector getRowCounts(matrixData& md) return rowcnt; } -std::vector getLocalStates(const GridComponent* comp, const solverMode& sMode) +std::vector getLocalStates(const GridComponent* comp, const SolverMode& sMode) { std::vector st; auto& off = comp->getOffsets(sMode); @@ -672,7 +672,7 @@ class objectCountInfo { }; /** function to get the actual Jacobian information about an object*/ objectCountInfo getObjectInformation(const GridComponent* comp, - const solverMode& sMode, + const SolverMode& sMode, const std::vector& rowCount) { objectCountInfo objI; @@ -725,7 +725,7 @@ void printObjCountInfo(const objectCountInfo& oi, int clevel, int maxLevel) void jacobianAnalysis(matrixData& md, GridDynSimulation* gds, - const solverMode& sMode, + const SolverMode& sMode, int level) { auto rc = getRowCounts(md); @@ -806,7 +806,7 @@ bool checkObjectEquivalence(const CoreObject* obj1, const CoreObject* obj2, bool } void printStateSizesPretty(const GridComponent* obj, - const solverMode& sMode, + const SolverMode& sMode, const std::string& inset) { auto& off = obj->getOffsets(sMode); @@ -826,7 +826,7 @@ void printStateSizesPretty(const GridComponent* obj, } } -void printStateSizes(const GridComponent* comp, const solverMode& sMode) +void printStateSizes(const GridComponent* comp, const SolverMode& sMode) { printStateSizesPretty(comp, sMode, ""); } diff --git a/src/griddyn/simulation/Diagnostics.h b/src/griddyn/simulation/Diagnostics.h index 6102d9b54..f646a8813 100644 --- a/src/griddyn/simulation/Diagnostics.h +++ b/src/griddyn/simulation/Diagnostics.h @@ -17,7 +17,7 @@ class matrixData; namespace griddyn { class GridDynSimulation; class GridComponent; -class solverMode; +class SolverMode; class SolverInterface; class CoreObject; @@ -29,35 +29,35 @@ and a numerically calculated version from the residual, It will not check Jacob dependent on other state derivatives This function is mostly useful for diagnosing problems and is used throughout the test suite @param[in] gds the GridDynSimulation object to test -@param[in] queryMode the solverMode to check the Jacobian for +@param[in] queryMode the SolverMode to check the Jacobian for @param[in] jacTol the tolerance to check matches @param[in] useStateNames set to true to collect and print state names (vs numbers) for any mismatch on the Jacobian check @return the number of mismatches */ int jacobianCheck(GridDynSimulation* gds, - const solverMode& queryMode, + const SolverMode& queryMode, double jacTol = jac_check_tol, bool useStateNames = false); /** @brief do a residual check function checks for any non-zero residuals usually used after an initialization or step. @param[in] gds the griddynSimulation object to test -@param[in] sMode the solverMode to check the residual +@param[in] sMode the SolverMode to check the residual @param[in] residTol the tolerance to check matches @param[in] useStateNames set to true to collect and print state names (vs numbers) for any mismatch on the Jacobian check @return the number of mismatches */ int residualCheck(GridDynSimulation* gds, - const solverMode& sMode, + const SolverMode& sMode, double residTol = resid_check_tol, bool useStateNames = false); /** @brief do a residual check function checks for any non-zero residuals usually used after an initialization or step. @param[in] gds the griddynSimulation object to test @param[in] time the time to check the residual -@param[in] sMode the solverMode to check the residual +@param[in] sMode the SolverMode to check the residual @param[in] residTol the tolerance to check matches @param[in] useStateNames set to true to collect and print state names (vs numbers) for any mismatch on the Jacobian check @@ -65,7 +65,7 @@ on the Jacobian check */ int residualCheck(GridDynSimulation* gds, coreTime time, - const solverMode& sMode, + const SolverMode& sMode, double residTol = resid_check_tol, bool useStateNames = false); @@ -75,24 +75,24 @@ std::pair checkResid(GridDynSimulation* gds, std::pair checkResid(GridDynSimulation* gds, coreTime time, const std::shared_ptr& sd); -std::pair checkResid(GridDynSimulation* gds, coreTime time, const solverMode& sMode); +std::pair checkResid(GridDynSimulation* gds, coreTime time, const SolverMode& sMode); int algebraicCheck(GridDynSimulation* gds, coreTime time, - const solverMode& sMode, + const SolverMode& sMode, double algTol = resid_check_tol, bool useStateNames = false); int derivativeCheck(GridDynSimulation* gds, coreTime time, - const solverMode& sMode, + const SolverMode& sMode, double derivTol = resid_check_tol, bool useStateNames = false); /** @brief do a convergence test on the solver */ void dynamicSolverConvergenceTest(GridDynSimulation* gds, - const solverMode& sMode, + const SolverMode& sMode, const std::string& file, count_t pts = 100000, int mode = 0); @@ -104,7 +104,7 @@ void dynamicSolverConvergenceTest(GridDynSimulation* gds, */ void jacobianAnalysis(matrixData& md, GridDynSimulation* gds, - const solverMode& sMode, + const SolverMode& sMode, int level); /** @brief check object equivalence @@ -124,5 +124,5 @@ object in a hierarchy @param[in] comp the component to print the state sizes for @param[in] sMode the solver mode of the states to print */ -void printStateSizes(const GridComponent* comp, const solverMode& sMode); +void printStateSizes(const GridComponent* comp, const SolverMode& sMode); } // namespace griddyn diff --git a/src/griddyn/simulation/DynamicInitialConditionRecovery.cpp b/src/griddyn/simulation/DynamicInitialConditionRecovery.cpp index b77ae1be6..d3634e68f 100644 --- a/src/griddyn/simulation/DynamicInitialConditionRecovery.cpp +++ b/src/griddyn/simulation/DynamicInitialConditionRecovery.cpp @@ -91,7 +91,7 @@ int dynamicInitialConditionRecovery::lowVoltageCheck() } return solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } @@ -107,7 +107,7 @@ int dynamicInitialConditionRecovery::dynamicFix1() 3.0); return solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } @@ -149,13 +149,13 @@ int dynamicInitialConditionRecovery::dynamicFix2() if (sim->dynamicCheckAndReset(solver->getSolverMode(), rootCheckResult)) { retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } } else { retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } } else { @@ -171,7 +171,7 @@ int dynamicInitialConditionRecovery::dynamicFix2() if (sim->dynamicCheckAndReset(solver->getSolverMode(), rootCheckResult)) { retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } } else { @@ -181,7 +181,7 @@ int dynamicInitialConditionRecovery::dynamicFix2() solver->getSolverMode()); retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } } @@ -194,7 +194,7 @@ int dynamicInitialConditionRecovery::dynamicFix2() 0.01); retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } return retval; @@ -218,21 +218,21 @@ int dynamicInitialConditionRecovery::dynamicFix3() double cr2 = checkResid(sim, timeCurr + 0.001, solver->getSolverMode()); // logging::debug(this, "tried alg converge from {} to {}", std::to_string(cr)); retval = solver->calcIC(timeCurr + 0.001, sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, true); + SolverInterface::IcModes::FIXED_DIFF, true); } else { sim->guessState(timeCurr + 0.001, solver->stateData(), solver->derivData(), solver->getSolverMode()); retval = solver->calcIC(timeCurr + 0.001, sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, true); + SolverInterface::IcModes::FIXED_DIFF, true); } } */ const int retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); return retval; } @@ -256,7 +256,7 @@ int dynamicInitialConditionRecovery::dynamicFix4() 0.01); const int retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); return retval; } @@ -272,7 +272,7 @@ int dynamicInitialConditionRecovery::dynamicFix5() 0.01); const int retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); return retval; } diff --git a/src/griddyn/simulation/FaultResetRecovery.cpp b/src/griddyn/simulation/FaultResetRecovery.cpp index 34ffefbc6..115eb6c0c 100644 --- a/src/griddyn/simulation/FaultResetRecovery.cpp +++ b/src/griddyn/simulation/FaultResetRecovery.cpp @@ -106,7 +106,7 @@ int faultResetRecovery::faultResetFix1() } } - return solver->calcIC(timeCurr, sim->probeStepTime, SolverInterface::IcModes::fixed_diff, true); + return solver->calcIC(timeCurr, sim->probeStepTime, SolverInterface::IcModes::FIXED_DIFF, true); } int faultResetRecovery::faultResetFix2(ResetLevels rlevel) @@ -121,7 +121,7 @@ int faultResetRecovery::faultResetFix2(ResetLevels rlevel) // int mmatch = jacobianCheck(sim, solver->getSolverMode()); retval = - solver->calcIC(timeCurr, sim->probeStepTime, SolverInterface::IcModes::fixed_diff, true); + solver->calcIC(timeCurr, sim->probeStepTime, SolverInterface::IcModes::FIXED_DIFF, true); if (retval != 0) { // try local converge with mode which only deals with low voltage buses sim->converge(timeCurr, @@ -134,7 +134,7 @@ int faultResetRecovery::faultResetFix2(ResetLevels rlevel) // sim->getVoltage(cVolts, solver->stateData(), solver->getSolverMode()); retval = solver->calcIC(timeCurr, sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } return retval; @@ -161,7 +161,7 @@ int faultResetRecovery::faultResetFix3() // dynData->printStates(true); retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); if (retval == 0) { @@ -181,7 +181,7 @@ int faultResetRecovery::faultResetFix3() // dynData->printStates(true); retval = solver->calcIC(sim->getSimulationTime(), sim->probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); if (retval == 0) { solver->getCurrentData(); diff --git a/src/griddyn/simulation/GridDynSimulation.cpp b/src/griddyn/simulation/GridDynSimulation.cpp index 3209b1855..5f3cb1e4a 100644 --- a/src/griddyn/simulation/GridDynSimulation.cpp +++ b/src/griddyn/simulation/GridDynSimulation.cpp @@ -392,9 +392,9 @@ double GridDynSimulation::getState(index_t offset) const return getState(offset, cLocalSolverMode); } -double GridDynSimulation::getState(index_t offset, const solverMode& sMode) const +double GridDynSimulation::getState(index_t offset, const SolverMode& sMode) const { - solverMode nMode = sMode; + SolverMode nMode = sMode; double ret = kNullVal; if (isLocal(sMode)) { switch (pState) { @@ -428,9 +428,9 @@ double GridDynSimulation::getState(index_t offset, const solverMode& sMode) cons return ret; } -std::vector GridDynSimulation::getState(const solverMode& sMode) const +std::vector GridDynSimulation::getState(const SolverMode& sMode) const { - solverMode nMode = sMode; + SolverMode nMode = sMode; if (isLocal(sMode)) { switch (pState) { case GridState::POWERFLOW_COMPLETE: @@ -473,7 +473,7 @@ grouped with the angle coming first differential_first = 5, //!< differential an with differential first */ -void GridDynSimulation::setupOffsets(const solverMode& sMode, OffsetOrdering offsetOrdering) +void GridDynSimulation::setupOffsets(const SolverMode& sMode, OffsetOrdering offsetOrdering) { solverOffsets offsetValues; switch (offsetOrdering) { @@ -801,7 +801,7 @@ bool GridDynSimulation::hasDynamics() const } // need to update probably with a new field in SolverInterface -count_t GridDynSimulation::nonZeros(const solverMode& sMode) const +count_t GridDynSimulation::nonZeros(const SolverMode& sMode) const { auto solverInterface = getSolverInterface(sMode); return solverInterface ? solverInterface->nonZeros() : 0; @@ -874,7 +874,7 @@ std::string GridDynSimulation::getString(std::string_view param) const return GridSimulation::getString(param); } -void GridDynSimulation::setDefaultMode(SolutionModes mode, const solverMode& sMode) +void GridDynSimulation::setDefaultMode(SolutionModes mode, const SolverMode& sMode) { auto solverData = getSolverInterface(sMode); if (!solverData) { @@ -1187,7 +1187,7 @@ void GridDynSimulation::alert(CoreObject* object, int code) } } -int GridDynSimulation::makeReady(GridState desiredState, const solverMode& sMode) +int GridDynSimulation::makeReady(GridState desiredState, const SolverMode& sMode) { // check to make sure we at or greater than the desiredState int retval = FUNCTION_EXECUTION_SUCCESS; @@ -1267,12 +1267,12 @@ int GridDynSimulation::countMpiObjects(bool printInfo) const return gridlabdObjects; } -void GridDynSimulation::setMaxNonZeros(const solverMode& sMode, count_t nonZeros) +void GridDynSimulation::setMaxNonZeros(const SolverMode& sMode, count_t nonZeros) { getSolverInterface(sMode)->setMaxNonZeros(nonZeros); } -std::shared_ptr GridDynSimulation::getSolverInterface(const solverMode& sMode) +std::shared_ptr GridDynSimulation::getSolverInterface(const SolverMode& sMode) { std::shared_ptr solveD; if (isValidIndex(sMode.offsetIndex, solverInterfaces)) { @@ -1287,7 +1287,7 @@ std::shared_ptr GridDynSimulation::getSolverInterface(const sol } std::shared_ptr - GridDynSimulation::getSolverInterface(const solverMode& sMode) const + GridDynSimulation::getSolverInterface(const SolverMode& sMode) const { if (isValidIndex(sMode.offsetIndex, solverInterfaces)) { return solverInterfaces[sMode.offsetIndex]; @@ -1325,9 +1325,9 @@ void GridDynSimulation::add(std::shared_ptr nSolver) updateSolver(sMode); } -solverMode GridDynSimulation::getSolverMode(std::string_view solverType) +SolverMode GridDynSimulation::getSolverMode(std::string_view solverType) { - solverMode sMode(kInvalidCount); + SolverMode sMode(kInvalidCount); if ((solverType == "ac") || (solverType == "acflow") || (solverType == "pflow") || (solverType == "powerflow")) { return *defPowerFlowMode; @@ -1376,7 +1376,7 @@ solverMode GridDynSimulation::getSolverMode(std::string_view solverType) } return sMode; } - const solverMode nMode = offsets.find(sMode); + const SolverMode nMode = offsets.find(sMode); if (nMode.offsetIndex != sMode.offsetIndex) { return nMode; } @@ -1388,7 +1388,7 @@ solverMode GridDynSimulation::getSolverMode(std::string_view solverType) return sMode; } -solverMode GridDynSimulation::getCurrentMode(const solverMode& sMode) const +SolverMode GridDynSimulation::getCurrentMode(const SolverMode& sMode) const { if (sMode.offsetIndex != kNullLocation) { return sMode; @@ -1420,7 +1420,7 @@ solverMode GridDynSimulation::getCurrentMode(const solverMode& sMode) const } } -const solverMode& GridDynSimulation::getSolverMode(index_t index) const +const SolverMode& GridDynSimulation::getSolverMode(index_t index) const { if (isValidIndex(index, solverInterfaces)) { return (solverInterfaces[index]) ? solverInterfaces[index]->getSolverMode() : @@ -1429,7 +1429,7 @@ const solverMode& GridDynSimulation::getSolverMode(index_t index) const return cEmptySolverMode; } -const solverMode* GridDynSimulation::getSolverModePtr(std::string_view solverType) const +const SolverMode* GridDynSimulation::getSolverModePtr(std::string_view solverType) const { if ((solverType == "ac") || (solverType == "acflow") || (solverType == "pflow") || (solverType == "powerflow")) { @@ -1453,7 +1453,7 @@ const solverMode* GridDynSimulation::getSolverModePtr(std::string_view solverTyp return nullptr; } -const solverMode* GridDynSimulation::getSolverModePtr(index_t index) const +const SolverMode* GridDynSimulation::getSolverModePtr(index_t index) const { if (isValidIndex(index, solverInterfaces)) { return (solverInterfaces[index]) ? &(solverInterfaces[index]->getSolverMode()) : nullptr; @@ -1501,10 +1501,10 @@ std::shared_ptr GridDynSimulation::getSolverInterface(std::stri return nullptr; } -std::shared_ptr GridDynSimulation::updateSolver(const solverMode& sMode) +std::shared_ptr GridDynSimulation::updateSolver(const SolverMode& sMode) { auto kIndex = sMode.offsetIndex; - solverMode solverModeValue = sMode; + SolverMode solverModeValue = sMode; if (!isValidIndex(kIndex, solverInterfaces)) { if ((kIndex > 10000) || (kIndex < 0)) { kIndex = static_cast(solverInterfaces.size()); @@ -1553,7 +1553,7 @@ void GridDynSimulation::parameterDerivatives(coreTime time, const double state[], const double dstateDt[], matrixData& matrixDataRef, - const solverMode& sMode) + const SolverMode& sMode) { const double delta = 1e-7; for (index_t ii = 0; ii < parameterCount; ++ii) { @@ -1601,7 +1601,7 @@ void GridDynSimulation::parameterDerivatives(coreTime time, } } -void GridDynSimulation::checkOffsets(const solverMode& sMode) +void GridDynSimulation::checkOffsets(const SolverMode& sMode) { if (offsets.getAlgOffset(sMode) == kNullLocation) { updateOffsets(sMode); @@ -1623,11 +1623,11 @@ void GridDynSimulation::addInitOperation(std::function fptr) additionalPowerflowSetupFunctions.push_back(std::move(fptr)); } } -void GridDynSimulation::fillExtraStateData(stateData& stateDataRef, const solverMode& sMode) const +void GridDynSimulation::fillExtraStateData(stateData& stateDataRef, const SolverMode& sMode) const { if ((!isDAE(sMode)) && (isDynamic(sMode))) { if (sMode.pairedOffsetIndex != kNullLocation) { - const solverMode& pSMode = getSolverMode(sMode.pairedOffsetIndex); + const SolverMode& pSMode = getSolverMode(sMode.pairedOffsetIndex); if (isDifferentialOnly(pSMode)) { if (extraStateInformation[pSMode.offsetIndex] != nullptr) { stateDataRef.diffState = extraStateInformation[pSMode.offsetIndex]; @@ -1653,7 +1653,7 @@ void GridDynSimulation::fillExtraStateData(stateData& stateDataRef, const solver } } -bool GridDynSimulation::checkEventsForDynamicReset(coreTime cTime, const solverMode& sMode) +bool GridDynSimulation::checkEventsForDynamicReset(coreTime cTime, const SolverMode& sMode) { if (EvQ->getNextTime() < cTime) { auto eventReturn = EvQ->executeEvents(cTime); diff --git a/src/griddyn/simulation/GridDynSimulationFileOps.cpp b/src/griddyn/simulation/GridDynSimulationFileOps.cpp index 8d04736e0..3b097655c 100644 --- a/src/griddyn/simulation/GridDynSimulationFileOps.cpp +++ b/src/griddyn/simulation/GridDynSimulationFileOps.cpp @@ -674,7 +674,7 @@ void savePowerFlowBinary(GridDynSimulation* /*gds*/, const std::string& /*fileNa void saveState(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode, + const SolverMode& sMode, bool append) { std::filesystem::path filePath(fileName); @@ -698,13 +698,13 @@ void saveState(GridDynSimulation* gds, void saveStateXML(GridDynSimulation* /*gds*/, const std::string& /*fileName*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } void saveStateBinary(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode, + const SolverMode& sMode, bool append) { const auto& currentMode = gds->getCurrentMode(sMode); @@ -815,7 +815,7 @@ void writeArray(coreTime time, } } -void loadState(GridDynSimulation* gds, const std::string& fileName, const solverMode& sMode) +void loadState(GridDynSimulation* gds, const std::string& fileName, const SolverMode& sMode) { const std::filesystem::path filePath(fileName); if (fileName.empty()) { @@ -843,9 +843,9 @@ void loadState(GridDynSimulation* gds, const std::string& fileName, const solver } } -void loadStateBinary(GridDynSimulation* gds, const std::string& fileName, const solverMode& sMode) +void loadStateBinary(GridDynSimulation* gds, const std::string& fileName, const SolverMode& sMode) { - const solverMode& currentMode = gds->getCurrentMode(sMode); + const SolverMode& currentMode = gds->getCurrentMode(sMode); auto solverInterface = gds->getSolverInterface(currentMode); if (!solverInterface) { return; @@ -869,12 +869,12 @@ void loadStateBinary(GridDynSimulation* gds, const std::string& fileName, const if (!solverInterface->isInitialized()) { solverInterface->allocate(dsize); } else { - gds->log(gds, PrintLevel::ERROR, "statefile does not match solverMode in size"); + gds->log(gds, PrintLevel::ERROR, "statefile does not match SolverMode in size"); return; } } // TODO(phlpt): Check this index at some point; the right handling is still unclear, - // might be used for automatic solverMode location instead of what is done currently. + // might be used for automatic SolverMode location instead of what is done currently. unsigned int outputIndex; bFile.read(reinterpret_cast(&outputIndex), sizeof(int)); bFile.read(reinterpret_cast(solverInterface->stateData()), sizeof(double) * dsize); @@ -885,7 +885,7 @@ void loadStateBinary(GridDynSimulation* gds, const std::string& fileName, const void loadStateXML(GridDynSimulation* /*gds*/, const std::string& /*fileName*/, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } @@ -948,7 +948,7 @@ void loadPowerFlowXML(GridDynSimulation* gds, const std::string& fileName) } } -void captureJacState(GridDynSimulation* gds, const std::string& fileName, const solverMode& sMode) +void captureJacState(GridDynSimulation* gds, const std::string& fileName, const SolverMode& sMode) { std::ofstream bFile(fileName.c_str(), std::ios::out | std::ios::binary); if (!bFile.is_open()) { @@ -995,7 +995,7 @@ void captureJacState(GridDynSimulation* gds, const std::string& fileName, const bFile.close(); } -void saveJacobian(GridDynSimulation* gds, const std::string& fileName, const solverMode& sMode) +void saveJacobian(GridDynSimulation* gds, const std::string& fileName, const SolverMode& sMode) { std::ofstream bFile(fileName.c_str(), std::ios::out | std::ios::binary); if (!bFile.is_open()) { diff --git a/src/griddyn/simulation/GridDynSimulationFileOps.h b/src/griddyn/simulation/GridDynSimulationFileOps.h index cb61b9cb3..feaafc9d7 100644 --- a/src/griddyn/simulation/GridDynSimulationFileOps.h +++ b/src/griddyn/simulation/GridDynSimulationFileOps.h @@ -16,7 +16,7 @@ class matrixData; namespace griddyn { // forward declare the template class matrixData -class solverMode; +class SolverMode; class GridDynSimulation; /** @brief save the current state to a file @@ -25,7 +25,7 @@ class GridDynSimulation; */ void saveState(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode = cEmptySolverMode, + const SolverMode& sMode = cEmptySolverMode, bool append = false); /** @brief save the bus data to a csv file @@ -46,17 +46,17 @@ void saveLineData(GridDynSimulation* gds, const std::string& fileName); */ void saveStateXML(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode = cEmptySolverMode); + const SolverMode& sMode = cEmptySolverMode); /** @brief save the current state to a binary file @param[in] gds the GridDynSimulation object to operate from @param[in] fileName the name of the file to save the state to -@param[in] sMode the solverMode to save the state +@param[in] sMode the SolverMode to save the state @param[in] append boolean indicating the file should be appended */ void saveStateBinary(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode = cEmptySolverMode, + const SolverMode& sMode = cEmptySolverMode, bool append = true); /** @brief load a state vector from a file @@ -65,7 +65,7 @@ void saveStateBinary(GridDynSimulation* gds, */ void loadState(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode = cEmptySolverMode); + const SolverMode& sMode = cEmptySolverMode); /** @brief load a binary state file @param[in] gds the GridDynSimulation object to operate from @@ -73,7 +73,7 @@ void loadState(GridDynSimulation* gds, */ void loadStateBinary(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode = cEmptySolverMode); + const SolverMode& sMode = cEmptySolverMode); /** @brief load a state vector from an XML file @param[in] gds the GridDynSimulation object to operate from @@ -81,25 +81,25 @@ void loadStateBinary(GridDynSimulation* gds, */ void loadStateXML(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode = cEmptySolverMode); + const SolverMode& sMode = cEmptySolverMode); /** @brief capture a Jacobian and a state to a file @param[in] gds the GridDynSimulation object to operate from @param[in] fileName the name of the file for storage -@param[in] sMode the solverMode to get the state from +@param[in] sMode the SolverMode to get the state from */ void captureJacState(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode = cEmptySolverMode); + const SolverMode& sMode = cEmptySolverMode); /** @brief capture the Jacobian data to a file @param[in] gds the GridDynSimulation object to operate from @param[in] fileName the name of the file for storage -@param[in] sMode the solverMode to get the state from +@param[in] sMode the SolverMode to get the state from */ void saveJacobian(GridDynSimulation* gds, const std::string& fileName, - const solverMode& sMode = cEmptySolverMode); + const SolverMode& sMode = cEmptySolverMode); /** @brief save the powerflow results to a file @param[in] gds the GridDynSimulation object to operate from diff --git a/src/griddyn/simulation/GridSimulation.cpp b/src/griddyn/simulation/GridSimulation.cpp index 0a2533343..ea22f32eb 100644 --- a/src/griddyn/simulation/GridSimulation.cpp +++ b/src/griddyn/simulation/GridSimulation.cpp @@ -121,7 +121,7 @@ int GridSimulation::step() return FUNCTION_EXECUTION_FAILURE; } -void GridSimulation::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void GridSimulation::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { GridArea::timestep(time, inputs, sMode); EvQ->executeEvents(time); diff --git a/src/griddyn/simulation/GridSimulation.h b/src/griddyn/simulation/GridSimulation.h index dd6d892ac..5e0229729 100644 --- a/src/griddyn/simulation/GridSimulation.h +++ b/src/griddyn/simulation/GridSimulation.h @@ -173,7 +173,7 @@ class GridSimulation: public GridArea { /** @brief get all the objects from the event Queue */ void getEventObjects(std::vector& objV) const; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; /** @brief run the simulator @param[in] finishTime the time to run to @return return code 0 for success other for failure diff --git a/src/griddyn/simulation/gridDynDynamic.cpp b/src/griddyn/simulation/gridDynDynamic.cpp index 9e7a8c8dc..61749c399 100644 --- a/src/griddyn/simulation/gridDynDynamic.cpp +++ b/src/griddyn/simulation/gridDynDynamic.cpp @@ -37,7 +37,7 @@ int GridDynSimulation::dynInitialize(coreTime tStart) if (opFlags[dyn_initialized]) { offsets.unload(true); } - const solverMode& tempSm = (defaultDynamicSolverMethod == DynamicSolverMethods::partitioned) ? + const SolverMode& tempSm = (defaultDynamicSolverMethod == DynamicSolverMethods::partitioned) ? *defDynDiffMode : *defDAEMode; @@ -47,7 +47,7 @@ int GridDynSimulation::dynInitialize(coreTime tStart) } auto dynData = getSolverInterface(tempSm); - const solverMode& solverModeRef = dynData->getSolverMode(); + const SolverMode& solverModeRef = dynData->getSolverMode(); if (defaultDynamicSolverMethod == DynamicSolverMethods::partitioned) { defDynDiffMode = &solverModeRef; } else { @@ -163,7 +163,7 @@ void GridDynSimulation::setupDynamicDAE() setDefaultMode(SolutionModes::dae_mode, getSolverMode("dae")); updateSolver(*defDAEMode); } - const solverMode& sMode = *defDAEMode; + const SolverMode& sMode = *defDAEMode; const int retval = makeReady(GridState::DYNAMIC_INITIALIZED, sMode); if (retval != FUNCTION_EXECUTION_SUCCESS) { logging::error(this, "Unable to prepare simulation for dynamic solution"); @@ -180,7 +180,7 @@ void GridDynSimulation::setupDynamicDAE() #define JAC_CHECK_ENABLED 0 int GridDynSimulation::dynamicDAEStartupConditions(std::shared_ptr& dynData, - const solverMode& sMode) + const SolverMode& sMode) { int retval = FUNCTION_EXECUTION_SUCCESS; if (pState == GridState::DYNAMIC_INITIALIZED) { @@ -189,7 +189,7 @@ int GridDynSimulation::dynamicDAEStartupConditions(std::shared_ptrcalcIC(currentTime, probeStepTime, - SolverInterface::IcModes::fixed_masked_and_deriv, + SolverInterface::IcModes::FIXED_MASKED_AND_DERIV, false); if (retval != FUNCTION_EXECUTION_SUCCESS) { // for (size_t kk = 0; kk < dynData->getSize(); ++kk) @@ -226,7 +226,7 @@ int GridDynSimulation::dynamicDAE(coreTime tStop) const int out = FUNCTION_EXECUTION_SUCCESS; int tstep = 0; - const solverMode& sMode = *defDAEMode; + const SolverMode& sMode = *defDAEMode; setupDynamicDAE(); auto dynData = getSolverInterface(sMode); @@ -331,8 +331,8 @@ int GridDynSimulation::dynamicDAE(coreTime tStop) void GridDynSimulation::setupDynamicPartitioned() { - const solverMode& sModeAlg = *defDynAlgMode; - const solverMode& sModeDiff = *defDynDiffMode; + const SolverMode& sModeAlg = *defDynAlgMode; + const SolverMode& sModeDiff = *defDynDiffMode; const int retval = makeReady(GridState::DYNAMIC_INITIALIZED, sModeDiff); if (retval != FUNCTION_EXECUTION_SUCCESS) { logging::error(this, "Unable to prepare simulation for dynamic solution"); @@ -355,8 +355,8 @@ void GridDynSimulation::setupDynamicPartitioned() int GridDynSimulation::dynamicPartitionedStartupConditions( std::shared_ptr& dynDataDiff, std::shared_ptr& dynDataAlg, - const solverMode& sModeDiff, - const solverMode& sModeAlg) + const SolverMode& sModeDiff, + const SolverMode& sModeAlg) { int retval = FUNCTION_EXECUTION_SUCCESS; if (pState == GridState::DYNAMIC_INITIALIZED) { @@ -368,7 +368,7 @@ int GridDynSimulation::dynamicPartitionedStartupConditions( guessState(currentTime, daeData->stateData(), daeData->derivData(), *defDAEMode); retval = daeData->calcIC(currentTime, probeStepTime, - SolverInterface::IcModes::fixed_masked_and_deriv, + SolverInterface::IcModes::FIXED_MASKED_AND_DERIV, false); if (retval != FUNCTION_EXECUTION_SUCCESS) { retval = generateDaeDynamicInitialConditions(*defDAEMode); @@ -529,7 +529,7 @@ int GridDynSimulation::step(coreTime nextStep, coreTime& timeActual) } } timeActual = currentTime; - const solverMode& solverModeRef = *defDAEMode; + const SolverMode& solverModeRef = *defDAEMode; int retval = FUNCTION_EXECUTION_SUCCESS; auto dynData = getSolverInterface(solverModeRef); @@ -545,7 +545,7 @@ int GridDynSimulation::step(coreTime nextStep, coreTime& timeActual) guessState(currentTime, dynData->stateData(), dynData->derivData(), solverModeRef); retval = dynData->calcIC(currentTime, probeStepTime, - SolverInterface::IcModes::fixed_masked_and_deriv, + SolverInterface::IcModes::FIXED_MASKED_AND_DERIV, false); if (retval != FUNCTION_EXECUTION_SUCCESS) { // for (size_t kk = 0; kk < dynData->getSize(); ++kk) @@ -651,7 +651,7 @@ void GridDynSimulation::handleEarlySolverReturn(int retval, dynData->getSolverMode(), CheckLevel::low_voltage_check); // return dynData->calcIC(getSimulationTime(), probeStepTime, - // SolverInterface::IcModes::fixed_diff, true); + // SolverInterface::IcModes::FIXED_DIFF, true); opFlags.reset(low_bus_voltage); #if JAC_CHECK_ENABLED > 0 int mmatch = jacobianCheck(this, dynData->getSolverMode()); @@ -663,7 +663,7 @@ void GridDynSimulation::handleEarlySolverReturn(int retval, } } -bool GridDynSimulation::dynamicCheckAndReset(const solverMode& sMode, ChangeCode change) +bool GridDynSimulation::dynamicCheckAndReset(const SolverMode& sMode, ChangeCode change) { auto dynData = getSolverInterface(sMode); if (opFlags[connectivity_change_flag]) { @@ -707,7 +707,7 @@ bool GridDynSimulation::dynamicCheckAndReset(const solverMode& sMode, ChangeCode return true; } -int GridDynSimulation::generateDaeDynamicInitialConditions(const solverMode& sMode) +int GridDynSimulation::generateDaeDynamicInitialConditions(const SolverMode& sMode) { auto dynData = getSolverInterface(sMode); int retval = FUNCTION_EXECUTION_FAILURE; @@ -735,7 +735,7 @@ int GridDynSimulation::generateDaeDynamicInitialConditions(const solverMode& sMo dynData->getSolverMode(), CheckLevel::low_voltage_check); // return dynData->calcIC(getSimulationTime(), probeStepTime, - // SolverInterface::IcModes::fixed_diff, true); + // SolverInterface::IcModes::FIXED_DIFF, true); opFlags.reset(low_bus_voltage); } // Do the first cut guessState at the solution @@ -759,7 +759,7 @@ int GridDynSimulation::generateDaeDynamicInitialConditions(const solverMode& sMo } retval = - dynData->calcIC(currentTime, probeStepTime, SolverInterface::IcModes::fixed_diff, true); + dynData->calcIC(currentTime, probeStepTime, SolverInterface::IcModes::FIXED_DIFF, true); if (retval == -22) { // this is bad initial conditions TODO:: map this to Solver ERROR codes not @@ -771,7 +771,7 @@ int GridDynSimulation::generateDaeDynamicInitialConditions(const solverMode& sMo ConvergeMode::single_iteration, 0.05); retval = - dynData->calcIC(currentTime, probeStepTime, SolverInterface::IcModes::fixed_diff, true); + dynData->calcIC(currentTime, probeStepTime, SolverInterface::IcModes::FIXED_DIFF, true); } if (retval == FUNCTION_EXECUTION_SUCCESS) { retval = checkAlgebraicRoots(dynData); @@ -796,8 +796,8 @@ int GridDynSimulation::generateDaeDynamicInitialConditions(const solverMode& sMo return retval; } -int GridDynSimulation::generatePartitionedDynamicInitialConditions(const solverMode& sModeAlg, - const solverMode& sModeDiff) +int GridDynSimulation::generatePartitionedDynamicInitialConditions(const SolverMode& sModeAlg, + const SolverMode& sModeDiff) { auto dynDataAlg = getSolverInterface(sModeAlg); auto dynDataDiff = getSolverInterface(sModeDiff); @@ -825,7 +825,7 @@ int GridDynSimulation::generatePartitionedDynamicInitialConditions(const solverM rootCheck(&sD, dynData->getSolverMode(), CheckLevel::low_voltage_check); //return dynData->calcIC(getSimulationTime(), probeStepTime, - SolverInterface::IcModes::fixed_diff, true); opFlags.reset(low_bus_voltage); + SolverInterface::IcModes::FIXED_DIFF, true); opFlags.reset(low_bus_voltage); */ } coreTime tRet; @@ -839,7 +839,7 @@ int GridDynSimulation::generatePartitionedDynamicInitialConditions(const solverM int GridDynSimulation::checkAlgebraicRoots(std::shared_ptr& dynData) { if (opFlags[has_alg_roots]) { - const solverMode& sMode = dynData->getSolverMode(); + const SolverMode& sMode = dynData->getSolverMode(); dynData->getCurrentData(); setState(currentTime + probeStepTime, dynData->stateData(), dynData->derivData(), sMode); updateLocalCache(); @@ -850,7 +850,7 @@ int GridDynSimulation::checkAlgebraicRoots(std::shared_ptr& dyn dynamicCheckAndReset(sMode, ret); int retval = dynData->calcIC(currentTime, probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); if (retval < 0) // this is bad initial conditions @@ -863,7 +863,7 @@ int GridDynSimulation::checkAlgebraicRoots(std::shared_ptr& dyn 0.05); retval = dynData->calcIC(currentTime, probeStepTime, - SolverInterface::IcModes::fixed_diff, + SolverInterface::IcModes::FIXED_DIFF, true); } return retval; @@ -872,7 +872,7 @@ int GridDynSimulation::checkAlgebraicRoots(std::shared_ptr& dyn return FUNCTION_EXECUTION_SUCCESS; } -int GridDynSimulation::handleStateChange(const solverMode& sMode) +int GridDynSimulation::handleStateChange(const SolverMode& sMode) { if (opFlags[state_change_flag]) { if (checkEventsForDynamicReset(currentTime + probeStepTime, sMode)) { @@ -885,7 +885,7 @@ int GridDynSimulation::handleStateChange(const solverMode& sMode) return HANDLER_NO_RETURN; } -void GridDynSimulation::handleRootChange(const solverMode& sMode, +void GridDynSimulation::handleRootChange(const SolverMode& sMode, std::shared_ptr& dynData) { if (opFlags[root_change_flag]) // something with the roots changed @@ -905,7 +905,7 @@ void GridDynSimulation::handleRootChange(const solverMode& sMode, } } -void GridDynSimulation::getConstraints(double consData[], const solverMode& sMode) +void GridDynSimulation::getConstraints(double consData[], const SolverMode& sMode) { // if ((controlFlags[voltage_constraints_flag]) || (opFlags[has_constraints])) if (controlFlags[voltage_constraints_flag]) { @@ -916,13 +916,13 @@ void GridDynSimulation::getConstraints(double consData[], const solverMode& sMod } } -void GridDynSimulation::updateOffsets(const solverMode& sMode) +void GridDynSimulation::updateOffsets(const SolverMode& sMode) { setupOffsets(sMode, default_ordering); setMaxNonZeros(sMode, jacSize(sMode)); } -int GridDynSimulation::reInitDyn(const solverMode& sMode) +int GridDynSimulation::reInitDyn(const SolverMode& sMode) { auto dynData = getSolverInterface(sMode); updateOffsets(sMode); @@ -983,7 +983,7 @@ int GridDynSimulation::residualFunction(coreTime time, const double state[], const double dstate_dt[], double resid[], - const solverMode& sMode) noexcept + const SolverMode& sMode) noexcept { ++residCount; stateData stateDataValue(time, state, dstate_dt, residCount); @@ -1137,7 +1137,7 @@ int GridDynSimulation::residualFunction(coreTime time, int GridDynSimulation::derivativeFunction(coreTime time, const double state[], double dstate_dt[], - const solverMode& sMode) noexcept + const SolverMode& sMode) noexcept { ++residCount; stateData stateDataValue(time, state, dstate_dt, residCount); @@ -1165,7 +1165,7 @@ int GridDynSimulation::jacobianFunction(coreTime time, const double dstate_dt[], matrixData& matrixDataRef, double cjValue, - const solverMode& sMode) noexcept + const SolverMode& sMode) noexcept { ++JacobianCallCount; // assuming it is the same data as the preceding residual call (it is for IDA but not sure if @@ -1186,7 +1186,7 @@ int GridDynSimulation::rootFindingFunction(coreTime time, const double state[], const double dstate_dt[], double roots[], - const solverMode& sMode) noexcept + const SolverMode& sMode) noexcept { stateData stateDataValue(time, state, dstate_dt, residCount); fillExtraStateData(stateDataValue, sMode); @@ -1197,7 +1197,7 @@ int GridDynSimulation::rootFindingFunction(coreTime time, int GridDynSimulation::dynAlgebraicSolve(coreTime time, const double diffState[], const double deriv[], - const solverMode& sMode) noexcept + const SolverMode& sMode) noexcept { extraStateInformation[sMode.offsetIndex] = diffState; extraDerivInformation[sMode.offsetIndex] = deriv; diff --git a/src/griddyn/simulation/gridDynPowerFlow.cpp b/src/griddyn/simulation/gridDynPowerFlow.cpp index 97472b90d..0c282ed87 100644 --- a/src/griddyn/simulation/gridDynPowerFlow.cpp +++ b/src/griddyn/simulation/gridDynPowerFlow.cpp @@ -28,7 +28,7 @@ namespace griddyn { // power flow solver int GridDynSimulation::powerflow() { - const solverMode& solverModeRef = *defPowerFlowMode; + const SolverMode& solverModeRef = *defPowerFlowMode; const int out = FUNCTION_EXECUTION_SUCCESS; count_t voltage_iteration_count = 0; count_t power_iteration_count = 0; @@ -218,7 +218,7 @@ int GridDynSimulation::powerflow() return out; } -void GridDynSimulation::reInitpFlow(const solverMode& sMode, ChangeCode change) +void GridDynSimulation::reInitpFlow(const SolverMode& sMode, ChangeCode change) { if (opFlags[slack_bus_change]) { checkNetwork(NetworkCheckType::FULL); @@ -299,7 +299,7 @@ int GridDynSimulation::pFlowInitialize(coreTime time0) EvQ->executeEvents(time0 - 0.001); auto pFlowData = getSolverInterface(*defPowerFlowMode); - const solverMode& solverModeRef = pFlowData->getSolverMode(); + const SolverMode& solverModeRef = pFlowData->getSolverMode(); defPowerFlowMode = &solverModeRef; // dynInitializeB // this->savePowerFlowXML("testflow.xml"); @@ -507,12 +507,12 @@ int GridDynSimulation::eventDrivenPowerflow(coreTime t_end, coreTime t_step) int GridDynSimulation::algUpdateFunction(coreTime time, const double state[], double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) noexcept { ++evalCount; stateData stateDataValue(time, state); - stateDataValue.seqID = (sMode.approx[force_recalc] ? 0 : evalCount); + stateDataValue.seqID = (sMode.approx[FORCE_RECALC] ? 0 : evalCount); #ifdef CHECK_STATE auto dynDataa = getSolverInterface(sMode); diff --git a/src/griddyn/solvers/ArkodeInterface.cpp b/src/griddyn/solvers/ArkodeInterface.cpp index 5aa31e477..5c7dcf59f 100644 --- a/src/griddyn/solvers/ArkodeInterface.cpp +++ b/src/griddyn/solvers/ArkodeInterface.cpp @@ -29,17 +29,17 @@ #include namespace griddyn::solvers { -int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_data); +int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, void* userData); int arkodeJac(sunrealtype time, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, SUNMatrix J, - void* user_data, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3); -int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data); +int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* userData); ArkodeInterface::ArkodeInterface(const std::string& objName): SundialsInterface(objName) { @@ -49,7 +49,7 @@ ArkodeInterface::ArkodeInterface(const std::string& objName): SundialsInterface( max_iterations = 1500; } -ArkodeInterface::ArkodeInterface(GridDynSimulation* gds, const solverMode& sMode): +ArkodeInterface::ArkodeInterface(GridDynSimulation* gds, const SolverMode& sMode): SundialsInterface(gds, sMode) { mode.dynamic = true; @@ -61,7 +61,7 @@ ArkodeInterface::ArkodeInterface(GridDynSimulation* gds, const solverMode& sMode ArkodeInterface::~ArkodeInterface() { // clear variables for CVode to use - if (flags[initialized_flag]) { + if (flags[INITIALIZED_FLAG]) { ARKodeFree(&solverMem); } } @@ -91,7 +91,7 @@ void ArkodeInterface::allocate(count_t stateCount, count_t numRoots) if (stateCount == svsize) { return; } - flags.reset(initialized_flag); + flags.reset(INITIALIZED_FLAG); a1.setRowLimit(stateCount); a1.setColLimit(stateCount); @@ -152,7 +152,7 @@ void ArkodeInterface::set(std::string_view param, double val) } if (checkStepUpdate) { - if (flags[initialized_flag]) { + if (flags[INITIALIZED_FLAG]) { ARKodeSetMaxStep(solverMem, maxStep); ARKodeSetMinStep(solverMem, minStep); ARKodeSetInitStep(solverMem, step); @@ -183,7 +183,7 @@ double ArkodeInterface::get(std::string_view param) const // output solver stats void ArkodeInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const { - if (!flags[initialized_flag]) { + if (!flags[INITIALIZED_FLAG]) { return; } int nni = 0; @@ -295,7 +295,7 @@ static const std::map arkodeRetCodes{ void ArkodeInterface::initialize(coreTime time0) { - if (!flags[allocated_flag]) { + if (!flags[ALLOCATED_FLAG]) { throw(InvalidSolverOperation()); } auto jsize = m_gds->jacSize(mode); @@ -326,7 +326,7 @@ void ArkodeInterface::initialize(coreTime time0) checkFlag(&retval, "ARKodeSetMaxNumSteps", 1); #ifdef ENABLE_KLU - if (flags[dense_flag]) { + if (flags[DENSE_FLAG]) { J = SUNDenseMatrix(svsize, svsize); checkFlag(J, "SUNDenseMatrix", 0); /* Create KLU solver object */ @@ -372,7 +372,7 @@ void ArkodeInterface::initialize(coreTime time0) checkFlag(&retval, "ARKodeSetInitStep", 1); } setConstraints(); - flags.set(initialized_flag); + flags.set(INITIALIZED_FLAG); } void ArkodeInterface::sparseReInit(SparseReinitMode sparseReinitMode) @@ -438,14 +438,14 @@ void ArkodeInterface::loadMaskElements() } // CVode C Functions -int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_data) +int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, void* userData) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(userData); sd->funcCallCount++; if (sd->mode.pairedOffsetIndex != kNullLocation) { int ret = sd->m_gds->dynAlgebraicSolve(time, NVECTOR_DATA(sd->use_omp, state), - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), sd->mode); if (ret < FUNCTION_EXECUTION_SUCCESS) { return ret; @@ -453,10 +453,10 @@ int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_ } int ret = sd->m_gds->derivativeFunction(time, NVECTOR_DATA(sd->use_omp, state), - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), sd->mode); - if (sd->flags[fileCapture_flag]) { + if (sd->flags[FILE_CAPTURE_FLAG]) { if (!sd->stateFile.empty()) { writeVector(time, STATE_INFORMATION, @@ -471,16 +471,16 @@ int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_ sd->funcCallCount, sd->mode.offsetIndex, sd->svsize, - NVECTOR_DATA(sd->use_omp, dstate_dt), + NVECTOR_DATA(sd->use_omp, dstateDt), sd->stateFile); } } return ret; } -int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data) +int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* userData) { - auto sd = reinterpret_cast(user_data); + auto sd = reinterpret_cast(userData); sd->m_gds->rootFindingFunction( time, NVECTOR_DATA(sd->use_omp, state), sd->derivData(), gout, sd->mode); @@ -489,14 +489,14 @@ int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* us int arkodeJac(sunrealtype time, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, SUNMatrix J, - void* user_data, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector /*tmp3*/) { - return sundialsJac(time, 0.0, state, dstate_dt, J, user_data, tmp1, tmp2); + return sundialsJac(time, 0.0, state, dstateDt, J, userData, tmp1, tmp2); } } // namespace griddyn::solvers diff --git a/src/griddyn/solvers/ArkodeInterface.h b/src/griddyn/solvers/ArkodeInterface.h index be008bb61..e4db6ebe8 100644 --- a/src/griddyn/solvers/ArkodeInterface.h +++ b/src/griddyn/solvers/ArkodeInterface.h @@ -33,9 +33,9 @@ class ArkodeInterface: public SundialsInterface { explicit ArkodeInterface(const std::string& objName = "arkode"); /** @brief alternate constructor @param[in] gds the GridDynSimulation object to connect to -@param[in] sMode the solverMode to solve For +@param[in] sMode the SolverMode to solve For */ - ArkodeInterface(GridDynSimulation* gds, const solverMode& sMode); + ArkodeInterface(GridDynSimulation* gds, const SolverMode& sMode); /** @brief destructor*/ virtual ~ArkodeInterface(); @@ -59,16 +59,16 @@ class ArkodeInterface: public SundialsInterface { virtual double get(std::string_view param) const override; // declare friend some helper functions - friend int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstate_dt, void* user_data); + friend int arkodeFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, void* userData); friend int arkodeJac(sunrealtype time, N_Vector state, - N_Vector dstate_dt, + N_Vector dstateDt, SUNMatrix J, - void* user_data, + void* userData, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3); - friend int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* user_data); + friend int arkodeRootFunc(sunrealtype time, N_Vector state, sunrealtype* gout, void* userData); protected: /** load up masking element if needed*/ diff --git a/src/griddyn/solvers/BasicOdeSolver.cpp b/src/griddyn/solvers/BasicOdeSolver.cpp index 5c53eeb01..3b143a43f 100644 --- a/src/griddyn/solvers/BasicOdeSolver.cpp +++ b/src/griddyn/solvers/BasicOdeSolver.cpp @@ -20,7 +20,7 @@ BasicOdeSolver::BasicOdeSolver(const std::string& objName): SolverInterface(objN mode.differential = true; mode.algebraic = false; } -BasicOdeSolver::BasicOdeSolver(GridDynSimulation* gds, const solverMode& sMode): +BasicOdeSolver::BasicOdeSolver(GridDynSimulation* gds, const SolverMode& sMode): SolverInterface(gds, sMode) { } @@ -73,18 +73,18 @@ void BasicOdeSolver::allocate(count_t stateCount, count_t numRoots) deriv.resize(stateCount); state2.resize(stateCount); svsize = stateCount; - flags.reset(initialized_flag); - flags.set(allocated_flag); + flags.reset(INITIALIZED_FLAG); + flags.set(ALLOCATED_FLAG); rootsfound.resize(numRoots); } } void BasicOdeSolver::initialize(coreTime t0) { - if (!flags[allocated_flag]) { + if (!flags[ALLOCATED_FLAG]) { throw(InvalidSolverOperation(-2)); } - flags.set(initialized_flag); + flags.set(INITIALIZED_FLAG); solverCallCount = 0; solveTime = t0; } diff --git a/src/griddyn/solvers/BasicOdeSolver.h b/src/griddyn/solvers/BasicOdeSolver.h index 0266e72ac..537b9e02a 100644 --- a/src/griddyn/solvers/BasicOdeSolver.h +++ b/src/griddyn/solvers/BasicOdeSolver.h @@ -28,9 +28,9 @@ class BasicOdeSolver: public SolverInterface { explicit BasicOdeSolver(const std::string& objName = "basicOde"); /** alternate constructor to feed to SolverInterface @param[in] gds the GridDynSimulation to link to -@param[in] sMode the solverMode to solve with +@param[in] sMode the SolverMode to solve with */ - BasicOdeSolver(GridDynSimulation* gds, const solverMode& sMode); + BasicOdeSolver(GridDynSimulation* gds, const SolverMode& sMode); virtual std::unique_ptr clone(bool fullCopy = false) const override; diff --git a/src/griddyn/solvers/BasicSolver.cpp b/src/griddyn/solvers/BasicSolver.cpp index 88ee3e4ad..7d45cab0a 100644 --- a/src/griddyn/solvers/BasicSolver.cpp +++ b/src/griddyn/solvers/BasicSolver.cpp @@ -30,7 +30,7 @@ namespace solvers { mode.algebraic = true; } - BasicSolver::BasicSolver(GridDynSimulation* gds, const solverMode& sMode): + BasicSolver::BasicSolver(GridDynSimulation* gds, const SolverMode& sMode): SolverInterface(gds, sMode), algorithm(Mode::gauss) { mode.algebraic = true; @@ -87,18 +87,18 @@ namespace solvers { tempState2.resize(stateCount); svsize = stateCount; - flags.reset(initialized_flag); - flags.set(allocated_flag); + flags.reset(INITIALIZED_FLAG); + flags.set(ALLOCATED_FLAG); rootsfound.resize(numRoots); } } void BasicSolver::initialize(coreTime /*time0*/) { - if (!flags[allocated_flag]) { + if (!flags[ALLOCATED_FLAG]) { throw(InvalidSolverOperation(-2)); } - flags.set(initialized_flag); + flags.set(INITIALIZED_FLAG); solverCallCount = 0; } @@ -118,10 +118,10 @@ namespace solvers { auto lcs = convertToLowerCase(val); if (lcs == "gauss") { algorithm = Mode::gauss; - mode.approx[force_recalc] = false; + mode.approx[FORCE_RECALC] = false; } else if (lcs == "gauss-seidel") { algorithm = Mode::gauss_seidel; - mode.approx[force_recalc] = true; + mode.approx[FORCE_RECALC] = true; } } else { SolverInterface::set(param, val); diff --git a/src/griddyn/solvers/BasicSolver.h b/src/griddyn/solvers/BasicSolver.h index 399313069..97db8a488 100644 --- a/src/griddyn/solvers/BasicSolver.h +++ b/src/griddyn/solvers/BasicSolver.h @@ -38,9 +38,9 @@ namespace solvers { explicit BasicSolver(const std::string& objName = "basic", Mode alg = Mode::gauss); /** alternate constructor to feed to SolverInterface @param[in] gds the GridDynSimulation to link to - @param[in] sMode the solverMode to solve with + @param[in] sMode the SolverMode to solve with */ - BasicSolver(GridDynSimulation* gds, const solverMode& sMode); + BasicSolver(GridDynSimulation* gds, const SolverMode& sMode); virtual std::unique_ptr clone(bool fullCopy = false) const override; diff --git a/src/griddyn/solvers/CvodeInterface.cpp b/src/griddyn/solvers/CvodeInterface.cpp index e2010f62e..996203a08 100644 --- a/src/griddyn/solvers/CvodeInterface.cpp +++ b/src/griddyn/solvers/CvodeInterface.cpp @@ -50,7 +50,7 @@ CvodeInterface::CvodeInterface(const std::string& objName): SundialsInterface(ob max_iterations = 1500; } -CvodeInterface::CvodeInterface(GridDynSimulation* gds, const solverMode& sMode): +CvodeInterface::CvodeInterface(GridDynSimulation* gds, const SolverMode& sMode): SundialsInterface(gds, sMode) { mode.dynamic = true; @@ -62,7 +62,7 @@ CvodeInterface::CvodeInterface(GridDynSimulation* gds, const solverMode& sMode): CvodeInterface::~CvodeInterface() { // clear variables for CVode to use - if (flags[initialized_flag]) { + if (flags[INITIALIZED_FLAG]) { CVodeFree(&solverMem); } } @@ -92,7 +92,7 @@ void CvodeInterface::allocate(count_t stateCount, count_t numRoots) if (stateCount == svsize) { return; } - flags.reset(initialized_flag); + flags.reset(INITIALIZED_FLAG); a1.setRowLimit(stateCount); a1.setColLimit(stateCount); @@ -151,7 +151,7 @@ void CvodeInterface::set(std::string_view param, double val) SolverInterface::set(param, val); } if (checkStepUpdate) { - if (flags[initialized_flag]) { + if (flags[INITIALIZED_FLAG]) { CVodeSetMaxStep(solverMem, maxStep); CVodeSetMinStep(solverMem, minStep); CVodeSetInitStep(solverMem, step); @@ -182,7 +182,7 @@ double CvodeInterface::get(std::string_view param) const // output solver stats void CvodeInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const { - if (!flags[initialized_flag]) { + if (!flags[INITIALIZED_FLAG]) { return; } long nni = 0; @@ -274,7 +274,7 @@ void CvodeInterface::logErrorWeights(PrintLevel logLevel) const void CvodeInterface::initialize(coreTime time0) { - if (!flags[allocated_flag]) { + if (!flags[ALLOCATED_FLAG]) { throw(InvalidSolverOperation()); } @@ -306,7 +306,7 @@ void CvodeInterface::initialize(coreTime time0) checkFlag(&retval, "CVodeSetMaxNumSteps", 1); #ifdef GRIDDYN_ENABLE_KLU - if (flags[dense_flag]) { + if (flags[DENSE_FLAG]) { J = SUNDenseMatrix(svsize, svsize, sunctx); checkFlag(J, "SUNDenseMatrix", 0); /* Create KLU solver object */ @@ -353,7 +353,7 @@ void CvodeInterface::initialize(coreTime time0) } setConstraints(); - flags.set(initialized_flag); + flags.set(INITIALIZED_FLAG); } void CvodeInterface::sparseReInit(SparseReinitMode reInitMode) @@ -441,7 +441,7 @@ int cvodeFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, void* userDat NVECTOR_DATA(sd->use_omp, dstateDt), sd->mode); - if (sd->flags[fileCapture_flag]) { + if (sd->flags[FILE_CAPTURE_FLAG]) { if (!sd->stateFile.empty()) { writeVector(time, STATE_INFORMATION, diff --git a/src/griddyn/solvers/CvodeInterface.h b/src/griddyn/solvers/CvodeInterface.h index 7f6818d32..c998f1766 100644 --- a/src/griddyn/solvers/CvodeInterface.h +++ b/src/griddyn/solvers/CvodeInterface.h @@ -31,9 +31,9 @@ class CvodeInterface: public SundialsInterface { explicit CvodeInterface(const std::string& objName = "cvode"); /** @brief alternate constructor @param[in] gds the GridDynSimulation object to connect to -@param[in] sMode the solverMode to solve For +@param[in] sMode the SolverMode to solve For */ - CvodeInterface(GridDynSimulation* gds, const solverMode& sMode); + CvodeInterface(GridDynSimulation* gds, const SolverMode& sMode); /** @brief destructor*/ virtual ~CvodeInterface(); diff --git a/src/griddyn/solvers/IdaInterface.cpp b/src/griddyn/solvers/IdaInterface.cpp index 88ace223b..10320257f 100644 --- a/src/griddyn/solvers/IdaInterface.cpp +++ b/src/griddyn/solvers/IdaInterface.cpp @@ -57,7 +57,7 @@ IdaInterface::IdaInterface(const std::string& objName): SundialsInterface(objNam max_iterations = 1500; } -IdaInterface::IdaInterface(GridDynSimulation* gds, const solverMode& sMode): +IdaInterface::IdaInterface(GridDynSimulation* gds, const SolverMode& sMode): SundialsInterface(gds, sMode) { max_iterations = 1500; @@ -66,7 +66,7 @@ IdaInterface::IdaInterface(GridDynSimulation* gds, const solverMode& sMode): IdaInterface::~IdaInterface() { // clear variables for IDA to use - if (flags[initialized_flag]) { + if (flags[INITIALIZED_FLAG]) { IDAFree(&solverMem); } } @@ -93,7 +93,7 @@ void IdaInterface::allocate(count_t stateCount, count_t numRoots) if (stateCount == svsize) { return; } - flags.reset(initialized_flag); + flags.reset(INITIALIZED_FLAG); a1.setRowLimit(stateCount); a1.setColLimit(stateCount); @@ -151,7 +151,7 @@ double IdaInterface::get(std::string_view param) const // output solver stats void IdaInterface::logSolverStats(PrintLevel logLevel, bool iconly) const { - if (!flags[initialized_flag]) { + if (!flags[INITIALIZED_FLAG]) { return; } long int nni = 0, nje = 0; @@ -257,7 +257,7 @@ void IdaInterface::logErrorWeights(PrintLevel logLevel) const void IdaInterface::initialize(coreTime t0) { - if (!flags[allocated_flag]) { + if (!flags[ALLOCATED_FLAG]) { throw(InvalidSolverOperation()); } auto jsize = m_gds->jacSize(mode); @@ -287,7 +287,7 @@ void IdaInterface::initialize(coreTime t0) retval = IDASetMaxNumSteps(solverMem, max_iterations); checkFlag(&retval, "IDASetMaxNumSteps", 1); #ifdef GRIDDYN_ENABLE_KLU - if (flags[dense_flag]) { + if (flags[DENSE_FLAG]) { J = SUNDenseMatrix(svsize, svsize, sunctx); checkFlag(J, "SUNDenseMatrix", 0); /* Create KLU solver object */ @@ -330,7 +330,7 @@ void IdaInterface::initialize(coreTime t0) setConstraints(); solveTime = t0; - flags.set(initialized_flag); + flags.set(INITIALIZED_FLAG); } void IdaInterface::sparseReInit(SparseReinitMode sparseReInitMode) @@ -356,13 +356,13 @@ int IdaInterface::calcIC(coreTime t0, coreTime tstep0, IcModes initCondMode, boo ++icCount; assert(icCount < 200); if (initCondMode == - IcModes::fixed_masked_and_deriv) // mainly for use upon startup from steady state + IcModes::FIXED_MASKED_AND_DERIV) // mainly for use upon startup from steady state { // do a series of steps to ensure the original algebraic states are fixed and the // derivatives are fixed - flags.set(useMask_flag); + flags.set(USE_MASK_FLAG); loadMaskElements(); - if (!flags[dense_flag]) { + if (!flags[DENSE_FLAG]) { sparseReInit(SparseReinitMode::REFACTOR); } retval = IDACalcIC(solverMem, IDA_Y_INIT, t0 + tstep0); // IDA_Y_INIT @@ -382,7 +382,7 @@ int IdaInterface::calcIC(coreTime t0, coreTime tstep0, IcModes initCondMode, boo tempState[me] = lstate[me]; } - if (!flags[dense_flag]) { + if (!flags[DENSE_FLAG]) { sparseReInit(SparseReinitMode::REFACTOR); } retval = IDACalcIC(solverMem, IDA_Y_INIT, t0 + tstep0); // IDA_Y_INIT @@ -406,11 +406,11 @@ int IdaInterface::calcIC(coreTime t0, coreTime tstep0, IcModes initCondMode, boo return retval; } } - flags.reset(useMask_flag); - if (!flags[dense_flag]) { + flags.reset(USE_MASK_FLAG); + if (!flags[DENSE_FLAG]) { sparseReInit(SparseReinitMode::REFACTOR); } - } else if (initCondMode == IcModes::fixed_diff) { + } else if (initCondMode == IcModes::FIXED_DIFF) { retval = IDAReInit(solverMem, t0, state, dstate_dt); if (retval < 0) { @@ -516,14 +516,14 @@ int idaFunc(sunrealtype time, N_Vector state, N_Vector dstateDt, N_Vector resid, NVECTOR_DATA(sd->use_omp, dstateDt), NVECTOR_DATA(sd->use_omp, resid), sd->mode); - if (sd->flags[useMask_flag]) { + if (sd->flags[USE_MASK_FLAG]) { auto lstate = NVECTOR_DATA(sd->use_omp, state); auto lresid = NVECTOR_DATA(sd->use_omp, resid); for (auto& v : sd->maskElements) { lresid[v] = 100.0 * (lstate[v] - sd->tempState[v]); } } - if (sd->flags[fileCapture_flag]) { + if (sd->flags[FILE_CAPTURE_FLAG]) { if (!sd->stateFile.empty()) { writeVector(sd->solveTime, STATE_INFORMATION, diff --git a/src/griddyn/solvers/IdaInterface.h b/src/griddyn/solvers/IdaInterface.h index cab07f6b6..16f3f8e87 100644 --- a/src/griddyn/solvers/IdaInterface.h +++ b/src/griddyn/solvers/IdaInterface.h @@ -28,9 +28,9 @@ class IdaInterface: public SundialsInterface { explicit IdaInterface(const std::string& objName = "ida"); /** @brief alternate constructor @param[in] gds the GridDynSimulation object to connect to -@param[in] sMode the solverMode to solve For +@param[in] sMode the SolverMode to solve For */ - IdaInterface(GridDynSimulation* gds, const solverMode& sMode); + IdaInterface(GridDynSimulation* gds, const SolverMode& sMode); /** @brief destructor*/ ~IdaInterface(); diff --git a/src/griddyn/solvers/KinsolInterface.cpp b/src/griddyn/solvers/KinsolInterface.cpp index 2029ba0d9..be08c44f6 100644 --- a/src/griddyn/solvers/KinsolInterface.cpp +++ b/src/griddyn/solvers/KinsolInterface.cpp @@ -53,7 +53,7 @@ KinsolInterface::KinsolInterface(const std::string& objName): SundialsInterface( max_iterations = 50; } -KinsolInterface::KinsolInterface(GridDynSimulation* gds, const solverMode& sMode): +KinsolInterface::KinsolInterface(GridDynSimulation* gds, const SolverMode& sMode): SundialsInterface(gds, sMode) { tolerance = 1e-8; @@ -65,7 +65,7 @@ KinsolInterface::KinsolInterface(GridDynSimulation* gds, const solverMode& sMode KinsolInterface::~KinsolInterface() { // clear the memory, the SundialsInterface destructor will clear the rest - if (flags[initialized_flag]) { + if (flags[INITIALIZED_FLAG]) { KINFree(&solverMem); } } @@ -105,7 +105,7 @@ void KinsolInterface::allocate(count_t stateCount, count_t /*numRoots*/) // output solver stats void KinsolInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const { - if (!flags[initialized_flag]) { + if (!flags[INITIALIZED_FLAG]) { return; } long int nni{0}; @@ -142,10 +142,10 @@ void KinsolInterface::logSolverStats(PrintLevel logLevel, bool /*iconly*/) const void KinsolInterface::initialize(coreTime /*t0*/) { - if (!flags[allocated_flag]) { + if (!flags[ALLOCATED_FLAG]) { throw(InvalidSolverOperation()); } - if (flags[directLogging_flag]) { + if (flags[DIRECT_LOGGING_FLAG]) { if (!(solverLogFile.empty())) { if (m_sundialsInfoFile == nullptr) { m_sundialsInfoFile = fopen(solverLogFile.c_str(), "w"); @@ -177,7 +177,7 @@ void KinsolInterface::initialize(coreTime /*t0*/) checkFlag(&retval, "KINInit", 1); #ifdef GRIDDYN_ENABLE_KLU - if (flags[dense_flag]) { + if (flags[DENSE_FLAG]) { J = SUNDenseMatrix(svsize, svsize, sunctx); checkFlag(J, "SUNDenseMatrix", 0); /* Create KLU solver object */ @@ -219,7 +219,7 @@ void KinsolInterface::initialize(coreTime /*t0*/) retval = KINSetNumMaxIters(solverMem, max_iterations); // residual calls checkFlag(&retval, "KINSetNumMaxIters", 1); - flags.set(initialized_flag); + flags.set(INITIALIZED_FLAG); } void KinsolInterface::sparseReInit(SparseReinitMode sparseReinitMode) @@ -361,7 +361,7 @@ int kinsolFunc(N_Vector state, N_Vector resid, void* userData) NVECTOR_DATA(sd->use_omp, resid), sd->mode); #endif - if (sd->flags[print_residuals]) { + if (sd->flags[PRINT_RESIDUALS]) { long int val = 0; KINGetNumNonlinSolvIters(sd->solverMem, &val); double* residuals = NVECTOR_DATA(sd->use_omp, resid); @@ -375,7 +375,7 @@ int kinsolFunc(N_Vector state, N_Vector resid, void* userData) } std::println("---------------------------------"); } - if (sd->flags[fileCapture_flag]) { + if (sd->flags[FILE_CAPTURE_FLAG]) { if (!sd->stateFile.empty()) { writeVector(sd->solveTime, STATE_INFORMATION, diff --git a/src/griddyn/solvers/KinsolInterface.h b/src/griddyn/solvers/KinsolInterface.h index dc263485e..8d68439ed 100644 --- a/src/griddyn/solvers/KinsolInterface.h +++ b/src/griddyn/solvers/KinsolInterface.h @@ -20,9 +20,9 @@ class KinsolInterface: public SundialsInterface { explicit KinsolInterface(const std::string& objName = "kinsol"); /** @brief constructor loading the SolverInterface structure* @param[in] gds the GridDynSimulation to link with -@param[in] sMode the solverMode for the solver +@param[in] sMode the SolverMode for the solver */ - KinsolInterface(GridDynSimulation* gds, const solverMode& sMode); + KinsolInterface(GridDynSimulation* gds, const SolverMode& sMode); /** @brief destructor */ virtual ~KinsolInterface(); diff --git a/src/griddyn/solvers/SolverInterface.cpp b/src/griddyn/solvers/SolverInterface.cpp index 14ade4bc3..303fb6a8e 100644 --- a/src/griddyn/solvers/SolverInterface.cpp +++ b/src/griddyn/solvers/SolverInterface.cpp @@ -75,7 +75,7 @@ static ChildClassFactory #endif SolverInterface::SolverInterface(const std::string& objName): HelperObject(objName) {} -SolverInterface::SolverInterface(GridDynSimulation* gds, const solverMode& sMode): +SolverInterface::SolverInterface(GridDynSimulation* gds, const SolverMode& sMode): mode(sMode), m_gds(gds) { } @@ -105,7 +105,7 @@ void SolverInterface::cloneTo(SolverInterface* si, bool fullCopy) const si->maskElements = maskElements; si->m_gds = m_gds; si->allocate(svsize, rootCount); - if (flags[initialized_flag]) { + if (flags[INITIALIZED_FLAG]) { si->initialize(0.0); } // copy the state data @@ -176,11 +176,11 @@ int SolverInterface::calcIC(coreTime /*t0*/, void SolverInterface::getCurrentData() {} void SolverInterface::getRoots() {} void SolverInterface::setRootFinding(index_t /*numRoots*/) {} -void SolverInterface::setSimulationData(const solverMode& sMode) +void SolverInterface::setSimulationData(const SolverMode& sMode) { mode = sMode; } -void SolverInterface::setSimulationData(GridDynSimulation* gds, const solverMode& sMode) +void SolverInterface::setSimulationData(GridDynSimulation* gds, const SolverMode& sMode) { mode = sMode; if (gds != nullptr) { @@ -310,24 +310,24 @@ void SolverInterface::set(std::string_view param, double val) } static const std::map> SOLVER_FLAG_MAP{ - {"filecapture", fileCapture_flag}, - {"directlogging", directLogging_flag}, - {"solver_log", directLogging_flag}, - {"dense", dense_flag}, - {"sparse", -dense_flag}, - {"parallel", parallel_flag}, - {"serial", -parallel_flag}, - {"mask", useMask_flag}, - {"constantjacobian", constantJacobian_flag}, - {"omp", use_omp_flag}, - {"useomp", use_omp_flag}, - {"bdf", use_bdf_flag}, - {"adams", -use_bdf_flag}, - {"functional", -use_newton_flag}, - {"newton", use_newton_flag}, - {"print_resid", print_residuals}, - {"print_residuals", print_residuals}, - {"block_mode_only", block_mode_only}}; + {"filecapture", FILE_CAPTURE_FLAG}, + {"directlogging", DIRECT_LOGGING_FLAG}, + {"solver_log", DIRECT_LOGGING_FLAG}, + {"dense", DENSE_FLAG}, + {"sparse", -DENSE_FLAG}, + {"parallel", PARALLEL_FLAG}, + {"serial", -PARALLEL_FLAG}, + {"mask", USE_MASK_FLAG}, + {"constantjacobian", CONSTANT_JACOBIAN_FLAG}, + {"omp", USE_OMP_FLAG}, + {"useomp", USE_OMP_FLAG}, + {"bdf", USE_BDF_FLAG}, + {"adams", -USE_BDF_FLAG}, + {"functional", -USE_NEWTON_FLAG}, + {"newton", USE_NEWTON_FLAG}, + {"print_resid", PRINT_RESIDUALS}, + {"print_residuals", PRINT_RESIDUALS}, + {"block_mode_only", BLOCK_MODE_ONLY}}; void SolverInterface::setFlag(std::string_view flag, bool val) { @@ -343,9 +343,9 @@ void SolverInterface::setFlag(std::string_view flag, bool val) } if (flag == "dc") { - mode.approx.set(dc, val); + mode.approx.set(DC, val); } else if (flag == "ac") { - mode.approx.set(dc, !val); + mode.approx.set(DC, !val); } else if (flag == "dynamic") { mode.dynamic = val; } else if (flag == "powerflow") { @@ -394,32 +394,32 @@ void SolverInterface::setFlag(std::string_view flag, bool val) void SolverInterface::setApproximation(std::string_view approx) { if ((approx == "normal") || (approx == "none")) { - setLinkApprox(mode, ApproxKeyMask::none); + setLinkApprox(mode, ApproxKeyMask::NONE); } else if ((approx == "simple") || (approx == "simplified")) { - setLinkApprox(mode, ApproxKeyMask::simplified); + setLinkApprox(mode, ApproxKeyMask::SIMPLIFIED); } else if (approx == "small_angle") { - setLinkApprox(mode, ApproxKeyMask::sm_angle); + setLinkApprox(mode, ApproxKeyMask::SM_ANGLE); } else if (approx == "small_angle_decoupled") { - setLinkApprox(mode, ApproxKeyMask::sm_angle_decoupled); + setLinkApprox(mode, ApproxKeyMask::SM_ANGLE_DECOUPLED); } else if (approx == "simplified_decoupled") { - setLinkApprox(mode, ApproxKeyMask::simplified_decoupled); + setLinkApprox(mode, ApproxKeyMask::SIMPLIFIED_DECOUPLED); } else if ((approx == "small_angle_simplified") || (approx == "simplified_small_angle")) { - setLinkApprox(mode, ApproxKeyMask::simplified_sm_angle); + setLinkApprox(mode, ApproxKeyMask::SIMPLIFIED_SM_ANGLE); } else if ((approx == "r") || (approx == "small_r")) { - setLinkApprox(mode, linear, false); - setLinkApprox(mode, small_r); + setLinkApprox(mode, LINEAR, false); + setLinkApprox(mode, SMALL_R); } else if (approx == "angle") { - setLinkApprox(mode, linear, false); - setLinkApprox(mode, small_angle); + setLinkApprox(mode, LINEAR, false); + setLinkApprox(mode, SMALL_ANGLE); } else if (approx == "coupling") { - setLinkApprox(mode, linear, false); - setLinkApprox(mode, decoupled); + setLinkApprox(mode, LINEAR, false); + setLinkApprox(mode, DECOUPLED); } else if (approx == "decoupled") { - setLinkApprox(mode, ApproxKeyMask::decoupled); + setLinkApprox(mode, ApproxKeyMask::DECOUPLED); } else if (approx == "linear") { - setLinkApprox(mode, ApproxKeyMask::linear); + setLinkApprox(mode, ApproxKeyMask::LINEAR); } else if ((approx == "fast_decoupled") || (approx == "fdpf")) { - setLinkApprox(mode, ApproxKeyMask::fast_decoupled); + setLinkApprox(mode, ApproxKeyMask::FAST_DECOUPLED); } else { throw(InvalidParameterValue(approx)); } @@ -536,27 +536,27 @@ void SolverInterface::setMaxNonZeros(count_t nonZeroCount) } // TODO(phlpt): Change this so the defaults can be something other than sundials solvers. -std::unique_ptr makeSolver(GridDynSimulation* gds, const solverMode& sMode) +std::unique_ptr makeSolver(GridDynSimulation* gds, const SolverMode& sMode) { std::unique_ptr sd = nullptr; if (isLocal(sMode)) { sd = std::make_unique(gds, sMode); } else if ((isAlgebraicOnly(sMode)) || (!isDynamic(sMode))) { sd = std::make_unique(gds, sMode); - if (sMode.offsetIndex == power_flow) { + if (sMode.offsetIndex == POWER_FLOW) { sd->setName("powerflow"); - } else if (sMode.offsetIndex == dynamic_algebraic) { + } else if (sMode.offsetIndex == DYNAMIC_ALGEBRAIC) { sd->setName("algebraic"); } } else if (isDAE(sMode)) { sd = std::make_unique(gds, sMode); - if (sMode.offsetIndex == dae) { + if (sMode.offsetIndex == DAE) { sd->setName("dynamic"); } } else if (isDifferentialOnly(sMode)) { sd = CoreClassFactory::instance()->createObject("differential"); sd->setSimulationData(gds, sMode); - if (sMode.offsetIndex == dynamic_differential) { + if (sMode.offsetIndex == DYNAMIC_DIFFERENTIAL) { sd->setName("differential"); } } diff --git a/src/griddyn/solvers/SolverInterface.h b/src/griddyn/solvers/SolverInterface.h index 4fd5bb66b..6e045cfde 100644 --- a/src/griddyn/solvers/SolverInterface.h +++ b/src/griddyn/solvers/SolverInterface.h @@ -58,33 +58,33 @@ class InvalidSolverOperation: public SolverException { #define SOLVER_CONVERGENCE_ERROR (-12) enum SolverFlags : int { - dense_flag = 0, //!< if the solver should use a dense or sparse version - constantJacobian_flag = 1, //!< if the solver should just keep a constant Jacobian - useMask_flag = 2, //!< if the solver should use a mask to filter out specific states - parallel_flag = 3, //!< if the solver should use a parallel version - locked_flag = 4, //!< if the solverMode is locked from further updates - use_omp_flag = 5, //!< flag indicating whether to use omp data constructs - allocated_flag = 6, //!< if the solver has been allocated - initialized_flag = 7, //!< flag indicating if these vectors have been initialized - fileCapture_flag = 8, - directLogging_flag = + DENSE_FLAG = 0, //!< if the solver should use a dense or sparse version + CONSTANT_JACOBIAN_FLAG = 1, //!< if the solver should just keep a constant Jacobian + USE_MASK_FLAG = 2, //!< if the solver should use a mask to filter out specific states + PARALLEL_FLAG = 3, //!< if the solver should use a parallel version + LOCKED_FLAG = 4, //!< if the SolverMode is locked from further updates + USE_OMP_FLAG = 5, //!< flag indicating whether to use omp data constructs + ALLOCATED_FLAG = 6, //!< if the solver has been allocated + INITIALIZED_FLAG = 7, //!< flag indicating if these vectors have been initialized + FILE_CAPTURE_FLAG = 8, + DIRECT_LOGGING_FLAG = 9, //!< flag telling the SolverInterface to capture a log directly from the solver - use_newton_flag = 11, - use_bdf_flag = 12, - block_mode_only = 13, //!< flag indicating that the solver only supports block mode - extra_solver_flag1 = 16, - extra_solver_flag2 = 17, - extra_solver_flag3 = 18, - extra_solver_flag4 = 19, - extra_solver_flag5 = 20, - extra_solver_flag6 = 21, - extra_solver_flag7 = 22, - extra_solver_flag8 = 23, - extra_solver_flag9 = 24, - extra_solver_flag10 = 25, - extra_solver_flag11 = 26, - extra_solver_flag12 = 27, - print_residuals = 28, + USE_NEWTON_FLAG = 11, + USE_BDF_FLAG = 12, + BLOCK_MODE_ONLY = 13, //!< flag indicating that the solver only supports block mode + EXTRA_SOLVER_FLAG1 = 16, + EXTRA_SOLVER_FLAG2 = 17, + EXTRA_SOLVER_FLAG3 = 18, + EXTRA_SOLVER_FLAG4 = 19, + EXTRA_SOLVER_FLAG5 = 20, + EXTRA_SOLVER_FLAG6 = 21, + EXTRA_SOLVER_FLAG7 = 22, + EXTRA_SOLVER_FLAG8 = 23, + EXTRA_SOLVER_FLAG9 = 24, + EXTRA_SOLVER_FLAG10 = 25, + EXTRA_SOLVER_FLAG11 = 26, + EXTRA_SOLVER_FLAG12 = 27, + PRINT_RESIDUALS = 28, }; /** @brief class defining the data related to a specific solver the SolverInterface class is the base class for solvers for the GridDyn power systems program @@ -101,8 +101,8 @@ class SolverInterface: public HelperObject { }; /** @brief enumeration of initiaL condition call modes*/ enum class IcModes { - fixed_masked_and_deriv, //!< fixed_algebraic and differential state derivatives - fixed_diff, //!< differential states are fixed + FIXED_MASKED_AND_DERIV, //!< fixed_algebraic and differential state derivatives + FIXED_DIFF, //!< differential states are fixed }; /** @brief enumeration of initiaL condition call modes*/ enum class SparseReinitMode { @@ -126,7 +126,7 @@ class SolverInterface: public HelperObject { count_t funcCallCount = 0; //!< the number of times the function evaluation has been called count_t rootCallCount = 0; count_t max_iterations = 10000; //!< the maximum number of iterations in the solver loop - solverMode mode; //!< to the solverMode + SolverMode mode; //!< to the SolverMode double tolerance = 1e-8; //!< the default solver tolerance coreTime solveTime = negTime; //!< storage for the time the solver is called std::string jacFile; //!< the file to write the Jacobian to @@ -144,9 +144,9 @@ class SolverInterface: public HelperObject { /** @brief alternate constructor @param[in] gds GridDynSimulation to link with - @param[in] sMode the solverMode associated with the solver + @param[in] sMode the SolverMode associated with the solver */ - SolverInterface(GridDynSimulation* gds, const solverMode& sMode); + SolverInterface(GridDynSimulation* gds, const SolverMode& sMode); /** @brief make a copy of the solver interface @param[in] fullCopy set to true to initialize and copy over all data to the new object @@ -269,7 +269,7 @@ class SolverInterface: public HelperObject { /** @brief check if the SolverInterface has been initialized @return true if initialized false if not */ - bool isInitialized() const { return flags[initialized_flag]; } + bool isInitialized() const { return flags[INITIALIZED_FLAG]; } /** @brief helper function to log specific solver stats @param[in] logLevel the level of logging to display @@ -292,9 +292,9 @@ class SolverInterface: public HelperObject { */ count_t nonZeros() const { return nnz; } - const solverMode& getSolverMode() const { return mode; } + const SolverMode& getSolverMode() const { return mode; } - void lock() { flags.set(locked_flag); } + void lock() { flags.set(LOCKED_FLAG); } void setIndex(index_t newIndex) { mode.offsetIndex = newIndex; } /** @brief print out all the state values @@ -303,18 +303,18 @@ class SolverInterface: public HelperObject { void printStates(bool getNames = false); /** @brief input the simulation data to attach to @param[in] gds the GridDynSimulationObject to attach to - @param[in] sMode the solverMode associated with the solver + @param[in] sMode the SolverMode associated with the solver */ - virtual void setSimulationData(GridDynSimulation* gds, const solverMode& sMode); + virtual void setSimulationData(GridDynSimulation* gds, const SolverMode& sMode); /** @brief input the simulation data to attach to @param[in] gds the GridDynSimulationObject to attach to */ virtual void setSimulationData(GridDynSimulation* gds); - /** @brief input the solverMode associated with the solver - @param[in] sMode the solverMode to attach to + /** @brief input the SolverMode associated with the solver + @param[in] sMode the SolverMode to attach to */ - virtual void setSimulationData(const solverMode& sMode); + virtual void setSimulationData(const SolverMode& sMode); void setApproximation(std::string_view approx); /** @brief load up masks to the states @@ -361,10 +361,10 @@ class SolverInterface: public HelperObject { /** @brief make a solver from a particular mode @param[in] gds the GridDynSimulation to link to -@param[in] sMode the solverMode to construct the SolverInterface from +@param[in] sMode the SolverMode to construct the SolverInterface from @return a unique_ptr to a SolverInterface object */ -std::unique_ptr makeSolver(GridDynSimulation* gds, const solverMode& sMode); +std::unique_ptr makeSolver(GridDynSimulation* gds, const SolverMode& sMode); /** @brief make a solver from a string @param[in] type the type of SolverInterface to create @return a unique_ptr to a SolverInterface object diff --git a/src/griddyn/solvers/SolverMode.hpp b/src/griddyn/solvers/SolverMode.hpp index a29c1e90f..efec03a99 100644 --- a/src/griddyn/solvers/SolverMode.hpp +++ b/src/griddyn/solvers/SolverMode.hpp @@ -22,25 +22,25 @@ namespace griddyn { * DAE the full DAE Solution mode */ enum ApproxKey { - decoupled = 0, - small_angle = 1, - small_r = 2, - linear = 3, - force_recalc = 29, - dc = 31, + DECOUPLED = 0, + SMALL_ANGLE = 1, + SMALL_R = 2, + LINEAR = 3, + FORCE_RECALC = 29, + DC = 31, }; enum class ApproxKeyMask : unsigned int { - none = 0, - decoupled = (1 << ApproxKey::decoupled), - sm_angle = (1 << ApproxKey::small_angle), - simplified = (1 << ApproxKey::small_r), - simplified_decoupled = (1 << ApproxKey::decoupled) + (1 << ApproxKey::small_r), - simplified_sm_angle = (1 << ApproxKey::small_angle) + (1 << ApproxKey::small_r), - sm_angle_decoupled = (1 << ApproxKey::decoupled) + (1 << ApproxKey::small_angle), - fast_decoupled = - (1 << ApproxKey::small_r) + (1 << ApproxKey::small_angle) + (1 << ApproxKey::decoupled), - linear = (1 << ApproxKey::linear), + NONE = 0, + DECOUPLED = (1 << ApproxKey::DECOUPLED), + SM_ANGLE = (1 << ApproxKey::SMALL_ANGLE), + SIMPLIFIED = (1 << ApproxKey::SMALL_R), + SIMPLIFIED_DECOUPLED = (1 << ApproxKey::DECOUPLED) + (1 << ApproxKey::SMALL_R), + SIMPLIFIED_SM_ANGLE = (1 << ApproxKey::SMALL_ANGLE) + (1 << ApproxKey::SMALL_R), + SM_ANGLE_DECOUPLED = (1 << ApproxKey::DECOUPLED) + (1 << ApproxKey::SMALL_ANGLE), + FAST_DECOUPLED = + (1 << ApproxKey::SMALL_R) + (1 << ApproxKey::SMALL_ANGLE) + (1 << ApproxKey::DECOUPLED), + LINEAR = (1 << ApproxKey::LINEAR), }; #ifdef _MSC_VER @@ -59,15 +59,15 @@ KEY_QUAL unsigned int indexVal(ApproxKeyMask key) } enum DefinedSolverModes : index_t { - local_mode = 0, - power_flow = 1, - dae = 2, - dynamic_algebraic = 3, - dynamic_differential = 4, + LOCAL_MODE = 0, + POWER_FLOW = 1, + DAE = 2, + DYNAMIC_ALGEBRAIC = 3, + DYNAMIC_DIFFERENTIAL = 4, }; /** @brief class defining how a specific solver operates and how to find information*/ -class solverMode { +class SolverMode { public: bool dynamic = false; //!< indicate if the solver is for dynamic simulation bool differential = false; //!< indicate if the solver uses differential states @@ -80,38 +80,38 @@ class solverMode { //!(request not obligation) index_t offsetIndex = kNullLocation; //!< index into an array of solverOffsets index_t pairedOffsetIndex = - kNullLocation; //!< the index of a paired solverMode --namely one containing state + kNullLocation; //!< the index of a paired SolverMode --namely one containing state //! information not calculated by this mode - /**@brief solverMode constructor + /**@brief SolverMode constructor @param[in] index the index to put in offsetIndex*/ - constexpr explicit solverMode(index_t index): offsetIndex(index) + constexpr explicit SolverMode(index_t index): offsetIndex(index) { - if (index == local_mode) { // predefined local + if (index == LOCAL_MODE) { // predefined local local = true; dynamic = true; differential = true; algebraic = true; - } else if (index == power_flow) { // predefined pflow + } else if (index == POWER_FLOW) { // predefined pflow algebraic = true; differential = false; dynamic = false; - } else if (index == dae) { // predefined dae + } else if (index == DAE) { // predefined dae dynamic = true; differential = true; algebraic = true; - } else if (index == dynamic_algebraic) { // predefined dynAlg + } else if (index == DYNAMIC_ALGEBRAIC) { // predefined dynAlg algebraic = true; differential = false; dynamic = true; - } else if (index == dynamic_differential) { // predefined dynDiff + } else if (index == DYNAMIC_DIFFERENTIAL) { // predefined dynDiff algebraic = false; differential = true; dynamic = true; } } - /**@brief solverMode default constructor*/ - constexpr solverMode() = default; - constexpr bool operator==(const solverMode& b) const + /**@brief SolverMode default constructor*/ + constexpr SolverMode() = default; + constexpr bool operator==(const SolverMode& b) const { return ((dynamic == b.dynamic) && (differential == b.differential) && (algebraic == b.algebraic) && (local == b.local) && @@ -120,60 +120,60 @@ class solverMode { }; #define LINKAPPROXMASK ((unsigned int)(0x000F)) -constexpr int getLinkApprox(const solverMode& sMode) +constexpr int getLinkApprox(const SolverMode& sMode) { return static_cast(sMode.approx.to_ulong() & (LINKAPPROXMASK)); } -inline void setLinkApprox(solverMode& sMode, ApproxKeyMask key) +inline void setLinkApprox(SolverMode& sMode, ApproxKeyMask key) { sMode.approx &= (~LINKAPPROXMASK); sMode.approx |= indexVal(key); } -inline void setLinkApprox(solverMode& sMode, int val) +inline void setLinkApprox(SolverMode& sMode, int val) { sMode.approx.set(val); } -inline void setLinkApprox(solverMode& sMode, int val, bool setval) +inline void setLinkApprox(SolverMode& sMode, int val, bool setval) { sMode.approx.set(val, setval); } -inline constexpr solverMode cLocalSolverMode(local_mode); -inline constexpr solverMode cPflowSolverMode(power_flow); -inline constexpr solverMode cDaeSolverMode(dae); -inline constexpr solverMode cDynAlgSolverMode(dynamic_algebraic); -inline constexpr solverMode cDynDiffSolverMode(dynamic_differential); +inline constexpr SolverMode cLocalSolverMode(LOCAL_MODE); +inline constexpr SolverMode cPflowSolverMode(POWER_FLOW); +inline constexpr SolverMode cDaeSolverMode(DAE); +inline constexpr SolverMode cDynAlgSolverMode(DYNAMIC_ALGEBRAIC); +inline constexpr SolverMode cDynDiffSolverMode(DYNAMIC_DIFFERENTIAL); -inline constexpr solverMode cEmptySolverMode{}; +inline constexpr SolverMode cEmptySolverMode{}; /** *Helper functions for determining mode capabilities **/ /** * @brief determine if the mode is dc only **/ -constexpr bool isDC(const solverMode& sMode) +constexpr bool isDC(const SolverMode& sMode) { - return sMode.approx[dc]; + return sMode.approx[DC]; } /** * @brief determine if the mode is AC only **/ -constexpr bool isAC(const solverMode& sMode) +constexpr bool isAC(const SolverMode& sMode) { - return !sMode.approx[dc]; + return !sMode.approx[DC]; } /** * @brief set the approximation mode to be DC **/ -inline void setDC(solverMode& sMode) +inline void setDC(SolverMode& sMode) { - sMode.approx.set(dc); + sMode.approx.set(DC); } /** * @brief determine if the mode requires dynamic initialization **/ -constexpr bool isDynamic(const solverMode& sMode) +constexpr bool isDynamic(const SolverMode& sMode) { return sMode.dynamic; } @@ -181,56 +181,56 @@ constexpr bool isDynamic(const solverMode& sMode) * @brief determine if the mode is for power flow @details isPowerFlow()==(!isDynamic()) **/ -constexpr bool isPowerFlow(const solverMode& sMode) +constexpr bool isPowerFlow(const SolverMode& sMode) { return !sMode.dynamic; } /** * @brief determine if the mode only uses algebraic variables **/ -constexpr bool isAlgebraicOnly(const solverMode& sMode) +constexpr bool isAlgebraicOnly(const SolverMode& sMode) { return (sMode.algebraic) && (!sMode.differential); } /** * @brief determine if the mode only uses differential variables **/ -constexpr bool isDifferentialOnly(const solverMode& sMode) +constexpr bool isDifferentialOnly(const SolverMode& sMode) { return (!sMode.algebraic) && (sMode.differential); } /** * @brief determine if the mode uses both algebraic and differential variables **/ -constexpr bool isDAE(const solverMode& sMode) +constexpr bool isDAE(const SolverMode& sMode) { return (sMode.algebraic) && (sMode.differential); } /** * @brief determine if the mode is a local mode **/ -constexpr bool isLocal(const solverMode& sMode) +constexpr bool isLocal(const SolverMode& sMode) { return sMode.local; } /** * @brief determine if the mode has differential components to it **/ -constexpr bool hasDifferential(const solverMode& sMode) +constexpr bool hasDifferential(const SolverMode& sMode) { return sMode.differential; } /** * @brief determine if the mode has algebraic components to it **/ -constexpr bool hasAlgebraic(const solverMode& sMode) +constexpr bool hasAlgebraic(const SolverMode& sMode) { return sMode.algebraic; } /** * @brief determine if the bus is using extended state information (namely Pin and Qin) **/ -constexpr bool isExtended(const solverMode& sMode) +constexpr bool isExtended(const SolverMode& sMode) { return sMode.extended_state; } diff --git a/src/griddyn/solvers/SundialsInterface.cpp b/src/griddyn/solvers/SundialsInterface.cpp index a73b7c81e..93b79c66d 100644 --- a/src/griddyn/solvers/SundialsInterface.cpp +++ b/src/griddyn/solvers/SundialsInterface.cpp @@ -61,7 +61,7 @@ SundialsInterface::SundialsInterface(const std::string& objName): SolverInterfac checkFlag(&retval, "SUNContext_Create", 1); registerErrorHandler(); } -SundialsInterface::SundialsInterface(GridDynSimulation* gds, const solverMode& sMode): +SundialsInterface::SundialsInterface(GridDynSimulation* gds, const SolverMode& sMode): SolverInterface(gds, sMode) { ensureSundialsFactories(); @@ -92,7 +92,7 @@ SundialsInterface::~SundialsInterface() if (types != nullptr) { NVECTOR_DESTROY(use_omp, types); } - if (flags[initialized_flag]) { + if (flags[INITIALIZED_FLAG]) { if (m_sundialsInfoFile != nullptr) { static_cast(fclose(m_sundialsInfoFile)); } @@ -123,7 +123,7 @@ void SundialsInterface::cloneTo(SolverInterface* si, bool fullCopy) const return; } ai->maxNNZ = maxNNZ; - if ((fullCopy) && (flags[allocated_flag])) { + if ((fullCopy) && (flags[ALLOCATED_FLAG])) { auto tols = nvecdata(use_omp, abstols); std::copy(tols, tols + svsize, nvecdata(use_omp, ai->abstols)); auto cons = nvecdata(use_omp, consData); @@ -141,8 +141,8 @@ void SundialsInterface::allocate(count_t stateCount, count_t /*numRoots*/) } [[maybe_unused]] bool prevOmp = use_omp; // looks unused if OPENMP is not available - use_omp = flags[use_omp_flag]; - flags.reset(initialized_flag); + use_omp = flags[USE_OMP_FLAG]; + flags.reset(INITIALIZED_FLAG); if (state != nullptr) { NVECTOR_DESTROY(prevOmp, state); } @@ -190,7 +190,7 @@ void SundialsInterface::allocate(count_t stateCount, count_t /*numRoots*/) svsize = stateCount; - flags.set(allocated_flag); + flags.set(ALLOCATED_FLAG); } void SundialsInterface::setMaxNonZeros(count_t nonZeroCount) @@ -248,7 +248,7 @@ void SundialsInterface::registerErrorHandler() void SundialsInterface::kluReInit(SparseReinitMode sparseReInitModes) { #ifdef GRIDDYN_ENABLE_KLU - if (flags[dense_flag]) { + if (flags[DENSE_FLAG]) { return; } switch (sparseReInitModes) { @@ -393,7 +393,7 @@ int sundialsJac(sunrealtype time, a1->setRowLimit(sd->svsize); a1->setColLimit(sd->svsize); - if (sd->flags[useMask_flag]) { + if (sd->flags[USE_MASK_FLAG]) { matrixDataFilter filterAd(*(a1)); filterAd.addFilter(sd->maskElements); sd->m_gds->jacobianFunction(time, @@ -425,7 +425,7 @@ int sundialsJac(sunrealtype time, #endif matrixDataToSUNMatrix(*a1, j, sd->svsize); sd->nnz = a1->size(); - if (sd->flags[fileCapture_flag]) { + if (sd->flags[FILE_CAPTURE_FLAG]) { if (!sd->jacFile.empty()) { auto val = static_cast(sd->get("nliterations")); writeArray(time, 1, val, sd->mode.offsetIndex, *a1, sd->jacFile); @@ -434,7 +434,7 @@ int sundialsJac(sunrealtype time, } else { // if it isn't the first we can use the SUNDIALS arraySparse object auto a1 = makeSundialsMatrixData(j); - if (sd->flags[useMask_flag]) { + if (sd->flags[USE_MASK_FLAG]) { matrixDataFilter filterAd(*a1); filterAd.addFilter(sd->maskElements); sd->m_gds->jacobianFunction(time, @@ -456,7 +456,7 @@ int sundialsJac(sunrealtype time, } sd->jacCallCount++; - if (sd->flags[fileCapture_flag]) { + if (sd->flags[FILE_CAPTURE_FLAG]) { if (!sd->jacFile.empty()) { writeArray(time, 1, sd->jacCallCount, sd->mode.offsetIndex, *a1, sd->jacFile); } @@ -466,7 +466,7 @@ int sundialsJac(sunrealtype time, matrixDataSparse &a1 = sd->a1; sd->m_gds->jacobianFunction (time, nvecdata(sd->use_omp, state), nvecdata(sd->use_omp, dstate_dt), -a1,cj, sd->mode); a1.sortIndexCol (); if (sd->flags[useMask_flag]) +a1,cj, sd->mode); a1.sortIndexCol (); if (sd->flags[USE_MASK_FLAG]) { for (auto &v : sd->maskElements) { @@ -496,7 +496,7 @@ J->rowvals[kk] = a1.rowIndex (kk); } J->colptrs[colval + 1] = static_cast (a1.size ()); -if (sd->flags[fileCapture_flag]) +if (sd->flags[FILE_CAPTURE_FLAG]) { if (!sd->jacFile.empty()) { diff --git a/src/griddyn/solvers/SundialsInterface.h b/src/griddyn/solvers/SundialsInterface.h index b71144029..534156072 100644 --- a/src/griddyn/solvers/SundialsInterface.h +++ b/src/griddyn/solvers/SundialsInterface.h @@ -91,9 +91,9 @@ class SundialsInterface: public SolverInterface { explicit SundialsInterface(const std::string& objName = "sundials"); /** @brief constructor loading the SolverInterface structure* @param[in] gds the GridDynSimulation to link with -@param[in] sMode the solverMode for the solver +@param[in] sMode the SolverMode for the solver */ - SundialsInterface(GridDynSimulation* gds, const solverMode& sMode); + SundialsInterface(GridDynSimulation* gds, const SolverMode& sMode); /** @brief destructor */ virtual ~SundialsInterface(); diff --git a/src/griddyn/solvers/SundialsMatrixData.h b/src/griddyn/solvers/SundialsMatrixData.h index 4cafe9335..4023d6920 100644 --- a/src/griddyn/solvers/SundialsMatrixData.h +++ b/src/griddyn/solvers/SundialsMatrixData.h @@ -28,7 +28,7 @@ class SundialsMatrixDataDense: public matrixData { void clear() override; - void assign(index_t X, index_t Y, double num) override; + void assign(index_t x, index_t y, double num) override; /** set the SUNDIALS matrix @param[in] mat the dense SUNDIALS matrix @@ -39,7 +39,7 @@ class SundialsMatrixDataDense: public matrixData { count_t capacity() const override; - matrixElement element(index_t N) const override; + matrixElement element(index_t n) const override; double at(index_t rowN, index_t colN) const override; }; @@ -69,7 +69,7 @@ class SundialsMatrixDataSparseColumn: public matrixData { count_t capacity() const override; - matrixElement element(index_t N) const override; + matrixElement element(index_t n) const override; double at(index_t rowN, index_t colN) const override; @@ -104,7 +104,7 @@ class SundialsMatrixDataSparseRow: public matrixData { count_t capacity() const override; - matrixElement element(index_t N) const override; + matrixElement element(index_t n) const override; double at(index_t rowN, index_t colN) const override; @@ -113,6 +113,6 @@ class SundialsMatrixDataSparseRow: public matrixData { virtual matrixElement next() override; }; -std::unique_ptr> makeSundialsMatrixData(SUNMatrix J); +std::unique_ptr> makeSundialsMatrixData(SUNMatrix j); } // namespace griddyn::solvers diff --git a/src/griddyn/sources/BlockSource.cpp b/src/griddyn/sources/BlockSource.cpp index 15d617220..1d7e7dceb 100644 --- a/src/griddyn/sources/BlockSource.cpp +++ b/src/griddyn/sources/BlockSource.cpp @@ -149,13 +149,13 @@ double blockSource::get(std::string_view param, units::unit unitType) const return rval; } -// void derivative(const IOdata &inputs, const stateData &sD, double deriv[], const solverMode +// void derivative(const IOdata &inputs, const stateData &sD, double deriv[], const SolverMode // &sMode); void blockSource::residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) + const SolverMode& sMode) { double srcOut = m_output; double srcDout = 0.0; @@ -172,7 +172,7 @@ void blockSource::residual(const IOdata& inputs, void blockSource::derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) + const SolverMode& sMode) { double srcOut = m_output; double srcDout = 0.0; @@ -189,7 +189,7 @@ void blockSource::derivative(const IOdata& inputs, void blockSource::algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) { double srcOut = m_output; @@ -206,7 +206,7 @@ void blockSource::jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) + const SolverMode& sMode) { double srcOut = m_output; double srcDout = 0.0; @@ -222,7 +222,7 @@ void blockSource::jacobianElements(const IOdata& inputs, } } -void blockSource::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void blockSource::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { while (prevTime < time) { auto ntime = std::min(prevTime + maxStepSize, time); @@ -240,7 +240,7 @@ void blockSource::timestep(coreTime time, const IOdata& inputs, const solverMode void blockSource::rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) + const SolverMode& sMode) { double srcOut = m_output; double srcDout = 0.0; @@ -256,7 +256,7 @@ void blockSource::rootTest(const IOdata& inputs, void blockSource::rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) + const SolverMode& sMode) { double srcOut = m_output; double srcDout = 0.0; @@ -272,7 +272,7 @@ void blockSource::rootTrigger(coreTime time, ChangeCode blockSource::rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) { double srcOut = m_output; @@ -293,7 +293,7 @@ ChangeCode blockSource::rootCheck(const IOdata& inputs, void blockSource::updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) + const SolverMode& sMode) { double srcOut = m_output; double srcDout = 0.0; @@ -319,7 +319,7 @@ void blockSource::setLevel(double newLevel) IOdata blockSource::getOutputs(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { if (blk != nullptr) { return blk->getOutputs(noInputs, sD, sMode); @@ -332,7 +332,7 @@ IOdata blockSource::getOutputs(const IOdata& /*inputs*/, double blockSource::getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum) const { if (blk != nullptr) { @@ -358,7 +358,7 @@ double blockSource::getOutput(index_t outputNum) const double blockSource::getDoutdt(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum) const { if (blk != nullptr) { diff --git a/src/griddyn/sources/BlockSource.h b/src/griddyn/sources/BlockSource.h index b5611fa9d..0b3940c39 100644 --- a/src/griddyn/sources/BlockSource.h +++ b/src/griddyn/sources/BlockSource.h @@ -43,63 +43,63 @@ namespace sources { units::unit unitType = units::defunit) const override; // virtual void derivative(const IOdata &inputs, const stateData &sD, double deriv[], const - // solverMode &sMode); + // SolverMode &sMode); virtual void residual(const IOdata& inputs, const stateData& sD, double resid[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void derivative(const IOdata& inputs, const stateData& sD, double deriv[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void algebraicUpdate(const IOdata& inputs, const stateData& sD, double update[], - const solverMode& sMode, + const SolverMode& sMode, double alpha) override; virtual void jacobianElements(const IOdata& inputs, const stateData& sD, matrixData& md, const IOlocs& inputLocs, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void - timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; virtual void rootTest(const IOdata& inputs, const stateData& sD, double roots[], - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual void rootTrigger(coreTime time, const IOdata& inputs, const std::vector& rootMask, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual ChangeCode rootCheck(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, CheckLevel level) override; virtual void updateLocalCache(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) override; + const SolverMode& sMode) override; virtual IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t num = 0) const override; virtual double getOutput(index_t outputNum = 0) const override; virtual double getDoutdt(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t num = 0) const override; virtual void setLevel(double newLevel) override; diff --git a/src/griddyn/sources/FileSource.cpp b/src/griddyn/sources/FileSource.cpp index 6a3b87971..e01c421d6 100644 --- a/src/griddyn/sources/FileSource.cpp +++ b/src/griddyn/sources/FileSource.cpp @@ -94,7 +94,7 @@ void fileSource::updateA(coreTime time) } } -void fileSource::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void fileSource::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { if (time > nextUpdateTime) { updateA(time); diff --git a/src/griddyn/sources/FileSource.h b/src/griddyn/sources/FileSource.h index 3582f02fa..cdb19b02a 100644 --- a/src/griddyn/sources/FileSource.h +++ b/src/griddyn/sources/FileSource.h @@ -44,7 +44,7 @@ class fileSource: public rampSource { virtual void pFlowObjectInitializeA(coreTime time0, std::uint32_t flags) override; virtual void updateA(coreTime time) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; // let predict fall through to ramp function private: diff --git a/src/griddyn/sources/FunctionSource.cpp b/src/griddyn/sources/FunctionSource.cpp index c39ea944f..c223a60fc 100644 --- a/src/griddyn/sources/FunctionSource.cpp +++ b/src/griddyn/sources/FunctionSource.cpp @@ -24,13 +24,13 @@ CoreObject* functionSource::clone(CoreObject* obj) const IOdata functionSource::getOutputs(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return {sourceFunc(sD.time)}; } double functionSource::getOutput(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t outputNum) const { return (outputNum == 0) ? sourceFunc(sD.time) : kNullVal; @@ -42,7 +42,7 @@ double functionSource::getOutput(index_t outputNum) const } double functionSource::getDoutdt(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t outputNum) const { return (outputNum == 0) ? ((sourceFunc(sD.time + 1e-7) - sourceFunc(sD.time)) / 1e-7) : 0.0; diff --git a/src/griddyn/sources/FunctionSource.h b/src/griddyn/sources/FunctionSource.h index 58450df18..908b30ab5 100644 --- a/src/griddyn/sources/FunctionSource.h +++ b/src/griddyn/sources/FunctionSource.h @@ -26,17 +26,17 @@ class functionSource: public Source { virtual IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const override; virtual double getOutput(index_t outputNum = 0) const override; virtual double getDoutdt(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const override; /** set the generation function @details the function should not have state as the input time is not unidirectional diff --git a/src/griddyn/sources/GrabberSource.cpp b/src/griddyn/sources/GrabberSource.cpp index d916999e8..39402c7dd 100644 --- a/src/griddyn/sources/GrabberSource.cpp +++ b/src/griddyn/sources/GrabberSource.cpp @@ -93,13 +93,13 @@ void grabberSource::dynObjectInitializeB(const IOdata& /*inputs*/, } IOdata grabberSource::getOutputs(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode) const + const SolverMode& sMode) const { return {gset->grabData(sD, sMode)}; } double grabberSource::getOutput(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum) const { if (outputNum == 0) { @@ -118,7 +118,7 @@ double grabberSource::getOutput(index_t outputNum) const double grabberSource::getDoutdt(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t /*outputNum*/) const { return 0.0; diff --git a/src/griddyn/sources/GrabberSource.h b/src/griddyn/sources/GrabberSource.h index b66de1434..ebafd2081 100644 --- a/src/griddyn/sources/GrabberSource.h +++ b/src/griddyn/sources/GrabberSource.h @@ -50,17 +50,17 @@ namespace sources { virtual IOdata getOutputs(const IOdata& inputs, const stateData& sD, - const solverMode& sMode) const override; + const SolverMode& sMode) const override; virtual double getOutput(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t outputNum = 0) const override; virtual double getOutput(index_t outputNum = 0) const override; virtual double getDoutdt(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t num = 0) const override; }; } // namespace sources diff --git a/src/griddyn/sources/PulseSource.cpp b/src/griddyn/sources/PulseSource.cpp index 49a961056..31bb57b7d 100644 --- a/src/griddyn/sources/PulseSource.cpp +++ b/src/griddyn/sources/PulseSource.cpp @@ -81,7 +81,7 @@ double pulseSource::computeOutput(coreTime time) const double pulseSource::getDoutdt(const IOdata& /*inputs*/, const stateData& stateData, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t /*num*/) const { double output1; diff --git a/src/griddyn/sources/PulseSource.h b/src/griddyn/sources/PulseSource.h index 9efcc409c..40a95e088 100644 --- a/src/griddyn/sources/PulseSource.h +++ b/src/griddyn/sources/PulseSource.h @@ -47,7 +47,7 @@ class pulseSource: public Source { virtual double computeOutput(coreTime time) const override; virtual double getDoutdt(const IOdata& inputs, const stateData& stateData, - const solverMode& sMode, + const SolverMode& sMode, index_t num = 0) const override; virtual void setLevel(double val) override; diff --git a/src/griddyn/sources/RampSource.cpp b/src/griddyn/sources/RampSource.cpp index 4f7bf3b12..ebf86df8a 100644 --- a/src/griddyn/sources/RampSource.cpp +++ b/src/griddyn/sources/RampSource.cpp @@ -45,7 +45,7 @@ double rampSource::computeOutput(coreTime time) const double rampSource::getDoutdt(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t num) const { return (num == 0) ? mp_dOdt : 0.0; diff --git a/src/griddyn/sources/RampSource.h b/src/griddyn/sources/RampSource.h index 496600e83..e45c97d4f 100644 --- a/src/griddyn/sources/RampSource.h +++ b/src/griddyn/sources/RampSource.h @@ -26,7 +26,7 @@ class rampSource: public Source { virtual double computeOutput(coreTime time) const override; virtual double getDoutdt(const IOdata& inputs, const stateData& sD, - const solverMode& sMode, + const SolverMode& sMode, index_t num = 0) const override; /** @brief clear the ramp (set it to 0)*/ void clearRamp() { mp_dOdt = 0.0; } diff --git a/src/griddyn/sources/RandomSource.cpp b/src/griddyn/sources/RandomSource.cpp index 73dbf074c..e9580af44 100644 --- a/src/griddyn/sources/RandomSource.cpp +++ b/src/griddyn/sources/RandomSource.cpp @@ -239,7 +239,7 @@ void randomSource::nextStep(coreTime triggerTime) } } -void randomSource::timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) +void randomSource::timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) { while (time >= nextUpdateTime) { updateA(nextUpdateTime); diff --git a/src/griddyn/sources/RandomSource.h b/src/griddyn/sources/RandomSource.h index 41cbe0a60..76572aa5d 100644 --- a/src/griddyn/sources/RandomSource.h +++ b/src/griddyn/sources/RandomSource.h @@ -49,7 +49,7 @@ class randomSource: public rampSource { virtual CoreObject* clone(CoreObject* obj = nullptr) const override; virtual void pFlowObjectInitializeA(coreTime time0, std::uint32_t flags) override; - virtual void timestep(coreTime time, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime time, const IOdata& inputs, const SolverMode& sMode) override; /** check if the random number generation has been triggered*/ bool isTriggered() { return opFlags[triggered_flag]; } diff --git a/src/griddyn/sources/Source.cpp b/src/griddyn/sources/Source.cpp index 6203d9c56..b1bbe03d1 100644 --- a/src/griddyn/sources/Source.cpp +++ b/src/griddyn/sources/Source.cpp @@ -79,7 +79,7 @@ void Source::set(std::string_view param, double val, units::unit unitType) void Source::setState(coreTime time, const double state[], const double dstate_dt[], - const solverMode& sMode) + const SolverMode& sMode) { updateOutput(time); GridComponent::setState(time, state, dstate_dt, sMode); @@ -95,7 +95,7 @@ void Source::updateOutput(coreTime time) lastTime = time; } -void Source::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& /*sMode*/) +void Source::timestep(coreTime time, const IOdata& /*inputs*/, const SolverMode& /*sMode*/) { if (time != prevTime) { updateOutput(time); @@ -104,20 +104,20 @@ void Source::timestep(coreTime time, const IOdata& /*inputs*/, const solverMode& } } -count_t Source::outputDependencyCount(index_t /*outputNum*/, const solverMode& /*sMode*/) const +count_t Source::outputDependencyCount(index_t /*outputNum*/, const SolverMode& /*sMode*/) const { return 0; } IOdata Source::getOutputs(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/) const + const SolverMode& /*sMode*/) const { return {m_tempOut}; } double Source::getOutput(const IOdata& /*inputs*/, const stateData& /*sD*/, - const solverMode& /*sMode*/, + const SolverMode& /*sMode*/, index_t outputNum) const { return (outputNum == 0) ? m_tempOut : kNullVal; @@ -133,13 +133,13 @@ units::unit Source::outputUnits(index_t outputNum) const return (outputNum == 0) ? outputUnits_ : units::defunit; } -index_t Source::getOutputLoc(const solverMode& /*sMode*/, index_t /*outputNum*/) const +index_t Source::getOutputLoc(const SolverMode& /*sMode*/, index_t /*outputNum*/) const { return kNullLocation; } void Source::updateLocalCache(const IOdata& /*inputs*/, const stateData& sD, - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { if ((prevTime != sD.time) && (sD.time > timeZero)) { m_tempOut = computeOutput(sD.time); diff --git a/src/griddyn/stabilizers/Stabilizer.cpp b/src/griddyn/stabilizers/Stabilizer.cpp index 1f3cbc61c..0752eb407 100644 --- a/src/griddyn/stabilizers/Stabilizer.cpp +++ b/src/griddyn/stabilizers/Stabilizer.cpp @@ -40,11 +40,11 @@ void Stabilizer::dynObjectInitializeB(const IOdata& /*inputs*/, void Stabilizer::residual(const IOdata& /*inputs*/, const stateData& /*sD*/, double /*resid*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } -index_t Stabilizer::findIndex(std::string_view /*field*/, const solverMode& /*sMode*/) const +index_t Stabilizer::findIndex(std::string_view /*field*/, const SolverMode& /*sMode*/) const { return kInvalidLocation; } @@ -65,7 +65,7 @@ void Stabilizer::jacobianElements(const IOdata& /*inputs*/, const stateData& /*sD*/, matrixData& /*md*/, const IOlocs& /*inputLocs*/, - const solverMode& sMode) + const SolverMode& sMode) { if (isAlgebraicOnly(sMode)) { return; @@ -75,7 +75,7 @@ void Stabilizer::jacobianElements(const IOdata& /*inputs*/, void Stabilizer::derivative(const IOdata& /*inputs*/, const stateData& /*sD*/, double /*deriv*/[], - const solverMode& /*sMode*/) + const SolverMode& /*sMode*/) { } diff --git a/src/griddyn_shared/griddyn_export.h b/src/griddyn_shared/griddyn_export.h index 447f28438..00e9854cf 100644 --- a/src/griddyn_shared/griddyn_export.h +++ b/src/griddyn_shared/griddyn_export.h @@ -40,7 +40,7 @@ typedef void* GridDynVectorQuery; /** typedef a GridDynEvent to a void * to represent an event in GridDyn*/ typedef void* GridDynEvent; -/** typedef * SolverKey to a void * to represent a solverMode object for use in a number of +/** typedef * SolverKey to a void * to represent a SolverMode object for use in a number of * functions*/ typedef void* SolverKey; diff --git a/src/griddyn_shared/griddyn_exportObjectMathFunctions.cpp b/src/griddyn_shared/griddyn_exportObjectMathFunctions.cpp index 15f1f84a3..0ec415d42 100644 --- a/src/griddyn_shared/griddyn_exportObjectMathFunctions.cpp +++ b/src/griddyn_shared/griddyn_exportObjectMathFunctions.cpp @@ -19,7 +19,7 @@ using griddyn::emptyStateData; using griddyn::GridComponent; using griddyn::IOdata; using griddyn::IOlocs; -using griddyn::solverMode; +using griddyn::SolverMode; using griddyn::stateData; static constexpr char invalidComponent[] = "the Griddyn object is not valid"; @@ -52,7 +52,7 @@ void setUpSolverKeyInfo(solverKeyInfo* key, GridComponent* comp) void TranslateToLocal(const std::vector& orig, double* newData, const GridComponent* comp, - const solverMode& sMode) + const SolverMode& sMode) { auto offsets = comp->getOffsets(sMode); double* cData = newData; @@ -80,7 +80,7 @@ void TranslateToLocal(const std::vector& orig, void CopyFromLocal(std::vector& dest, const double* localData, const GridComponent* comp, - const solverMode& sMode) + const SolverMode& sMode) { auto offsets = comp->getOffsets(sMode); const double* cData = localData; diff --git a/src/griddyn_shared/internal/griddyn_export_internal.h b/src/griddyn_shared/internal/griddyn_export_internal.h index 9c9089adb..58de90245 100644 --- a/src/griddyn_shared/internal/griddyn_export_internal.h +++ b/src/griddyn_shared/internal/griddyn_export_internal.h @@ -28,14 +28,14 @@ const griddyn::GridComponent* getConstComponentPointer(GridDynObject obj); /** data class for storing some solver information and data buffers*/ class solverKeyInfo { public: - griddyn::solverMode sMode_; //!< solverMode + griddyn::SolverMode sMode_; //!< SolverMode std::vector stateBuffer; //!< buffer for storing state data std::vector dstateBuffer; //!< buffer for storing dstate_dt data std::vector stateNames; //!< buffer for storing the stateNames /** default constructor*/ solverKeyInfo() = default; - /** constructor from a solverMode reference*/ - solverKeyInfo(const griddyn::solverMode& sMode): sMode_(sMode) {} + /** constructor from a SolverMode reference*/ + solverKeyInfo(const griddyn::SolverMode& sMode): sMode_(sMode) {} }; /** allocate buffers for using a solverKeyInfo object with a GridComponent*/ @@ -44,12 +44,12 @@ void setUpSolverKeyInfo(solverKeyInfo* key, griddyn::GridComponent* comp); void TranslateToLocal(const std::vector& orig, double* newData, const griddyn::GridComponent* comp, - const griddyn::solverMode& sMode); + const griddyn::SolverMode& sMode); /** translate a local state vector into the appropriate elements of a system state vector*/ void CopyFromLocal(std::vector& dest, const double* localData, const griddyn::GridComponent* comp, - const griddyn::solverMode& sMode); + const griddyn::SolverMode& sMode); /** definitions to simplify error returns if an error already exists*/ # define GRIDDYN_ERROR_CHECK(err, retval) \ diff --git a/src/helics/helicsGhostBus.cpp b/src/helics/helicsGhostBus.cpp index 96db1c375..d25eedbed 100644 --- a/src/helics/helicsGhostBus.cpp +++ b/src/helics/helicsGhostBus.cpp @@ -71,7 +71,7 @@ coreTime HelicsGhostBus::updateB() return nextUpdateTime; } -void HelicsGhostBus::timestep(coreTime ttime, const IOdata& inputs, const solverMode& sMode) +void HelicsGhostBus::timestep(coreTime ttime, const IOdata& inputs, const SolverMode& sMode) { while (ttime > nextUpdateTime) { updateA(nextUpdateTime); diff --git a/src/helics/helicsGhostBus.h b/src/helics/helicsGhostBus.h index 5b8e989e8..8d1d3eb89 100644 --- a/src/helics/helicsGhostBus.h +++ b/src/helics/helicsGhostBus.h @@ -31,7 +31,7 @@ class HelicsGhostBus: public GridBus { virtual void updateA(coreTime time) override; virtual coreTime updateB() override; - virtual void timestep(coreTime ttime, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime ttime, const IOdata& inputs, const SolverMode& sMode) override; virtual void setFlag(const std::string& param, bool val = true) override; virtual void set(const std::string& param, const std::string& val) override; virtual void diff --git a/src/helics/helicsLoad.cpp b/src/helics/helicsLoad.cpp index 389e43769..eb15f375d 100644 --- a/src/helics/helicsLoad.cpp +++ b/src/helics/helicsLoad.cpp @@ -127,7 +127,7 @@ coreTime HelicsLoad::updateB() return nextUpdateTime; } -void HelicsLoad::timestep(coreTime ttime, const IOdata& inputs, const solverMode& sMode) +void HelicsLoad::timestep(coreTime ttime, const IOdata& inputs, const SolverMode& sMode) { while (ttime > nextUpdateTime) { updateA(nextUpdateTime); diff --git a/src/helics/helicsLoad.h b/src/helics/helicsLoad.h index ef5c78bfd..86ebefd73 100644 --- a/src/helics/helicsLoad.h +++ b/src/helics/helicsLoad.h @@ -46,7 +46,7 @@ class HelicsLoad: public loads::RampLoad { virtual void updateA(coreTime time) override; virtual coreTime updateB() override; - virtual void timestep(coreTime ttime, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime ttime, const IOdata& inputs, const SolverMode& sMode) override; virtual void setFlag(const std::string& param, bool val = true) override; virtual void set(const std::string& param, const std::string& val) override; virtual void diff --git a/src/helics/helicsSource.cpp b/src/helics/helicsSource.cpp index 9dfec28c0..c29df37af 100644 --- a/src/helics/helicsSource.cpp +++ b/src/helics/helicsSource.cpp @@ -123,7 +123,7 @@ void HelicsSource::updateA(coreTime time) prevTime = time; } -void HelicsSource::timestep(coreTime ttime, const IOdata& inputs, const solverMode& sMode) +void HelicsSource::timestep(coreTime ttime, const IOdata& inputs, const SolverMode& sMode) { while (ttime >= nextUpdateTime) { updateA(nextUpdateTime); diff --git a/src/helics/helicsSource.h b/src/helics/helicsSource.h index 7b128a95d..a51be63f6 100644 --- a/src/helics/helicsSource.h +++ b/src/helics/helicsSource.h @@ -42,7 +42,7 @@ class HelicsSource: public sources::rampSource { virtual void dynObjectInitializeA(coreTime time0, uint32_t flags) override; virtual void updateA(coreTime time) override; - virtual void timestep(coreTime ttime, const IOdata& inputs, const solverMode& sMode) override; + virtual void timestep(coreTime ttime, const IOdata& inputs, const SolverMode& sMode) override; virtual void setFlag(const std::string& param, bool val = true) override; virtual void set(const std::string& param, const std::string& val) override; virtual void diff --git a/test/extraTests/objectSizeReport.cpp b/test/extraTests/objectSizeReport.cpp index 680e4e081..f1b43c4a0 100644 --- a/test/extraTests/objectSizeReport.cpp +++ b/test/extraTests/objectSizeReport.cpp @@ -26,7 +26,7 @@ TEST(ExtraSizeReportTests, ObjectSizeReport) { std::cout << "solverOffset size=" << sizeof(solverOffsets) << '\n'; std::cout << "offsetTableSize=" << sizeof(OffsetTable) << '\n'; - std::cout << "solverModeSize=" << sizeof(solverMode) << '\n'; + std::cout << "solverModeSize=" << sizeof(SolverMode) << '\n'; std::cout << "coreTime size = " << sizeof(coreTime) << '\n'; auto coreSize = sizeof(CoreObject); diff --git a/test/gtestHelper.h b/test/gtestHelper.h index 48d3f89fd..eb679a4da 100644 --- a/test/gtestHelper.h +++ b/test/gtestHelper.h @@ -39,7 +39,7 @@ static const char other_test_directory[] = GRIDDYN_TEST_DIRECTORY "/other_test_c namespace griddyn { class GridLoad; -class solverMode; +class SolverMode; } // namespace griddyn struct GridDynSimulationTestFixture { @@ -91,24 +91,24 @@ void requireStates(griddyn::GridDynSimulation::GridState state1, griddyn::GridDynSimulation::GridState state2); int runJacobianCheck(std::unique_ptr& gds, - const griddyn::solverMode& sMode, + const griddyn::SolverMode& sMode, bool checkRequired = true); int runJacobianCheck(std::unique_ptr& gds, - const griddyn::solverMode& sMode, + const griddyn::SolverMode& sMode, double tol, bool checkRequired = true); int runResidualCheck(std::unique_ptr& gds, - const griddyn::solverMode& sMode, + const griddyn::SolverMode& sMode, bool checkRequired = true); int runDerivativeCheck(std::unique_ptr& gds, - const griddyn::solverMode& sMode, + const griddyn::SolverMode& sMode, bool checkRequired = true); int runAlgebraicCheck(std::unique_ptr& gds, - const griddyn::solverMode& sMode, + const griddyn::SolverMode& sMode, bool checkRequired = true); void printBusResultDeviations(const std::vector& V1, diff --git a/test/gtestHelperFunctions.cpp b/test/gtestHelperFunctions.cpp index cbe719394..5ab919552 100644 --- a/test/gtestHelperFunctions.cpp +++ b/test/gtestHelperFunctions.cpp @@ -240,7 +240,7 @@ glbconfig::glbconfig() = default; glbconfig::~glbconfig() = default; int runJacobianCheck(std::unique_ptr& gds, - const solverMode& sMode, + const SolverMode& sMode, bool checkRequired) { int mmatch = jacobianCheck(gds.get(), sMode); @@ -254,7 +254,7 @@ int runJacobianCheck(std::unique_ptr& gds, } int runJacobianCheck(std::unique_ptr& gds, - const solverMode& sMode, + const SolverMode& sMode, double tol, bool checkRequired) { @@ -269,7 +269,7 @@ int runJacobianCheck(std::unique_ptr& gds, } int runResidualCheck(std::unique_ptr& gds, - const solverMode& sMode, + const SolverMode& sMode, bool checkRequired) { int mmatch = residualCheck(gds.get(), sMode); @@ -284,7 +284,7 @@ int runResidualCheck(std::unique_ptr& gds, } int runDerivativeCheck(std::unique_ptr& gds, - const solverMode& sMode, + const SolverMode& sMode, bool checkRequired) { int mmatch = derivativeCheck(gds.get(), gds->getSimulationTime(), sMode); @@ -298,7 +298,7 @@ int runDerivativeCheck(std::unique_ptr& gds, } int runAlgebraicCheck(std::unique_ptr& gds, - const solverMode& sMode, + const SolverMode& sMode, bool checkRequired) { int mmatch = algebraicCheck(gds.get(), gds->getSimulationTime(), sMode); diff --git a/test/test_files/IEEE_test_cases/118BUS.JPG b/test/test_files/IEEE_test_cases/118BUS.JPG index 3ce81fe11b43cbbf192263b234caac97bd103b5b..f4f1b5dbaef22ae166ed5ddd25793dca36c9a7fc 100644 GIT binary patch delta 14 VcmeygjOEKRmWC~iMZ!$HTmUkr1r7iJ delta 11 ScmeyejOEiZmWC~iMZy3hqXhK; diff --git a/test/test_files/IEEE_test_cases/14bus.jpg b/test/test_files/IEEE_test_cases/14bus.jpg index eca98abaf43a847f269a0f617af143362b33dc83..178fbf384707b283ed9b96a77ef37e4ef78880b9 100644 GIT binary patch delta 12 TcmeA~WQCSEQ8B4-3( delta 9 QcmeA>!rXI&c>~WQ02OWoM*si- diff --git a/test/test_files/IEEE_test_cases/300BUS.JPG b/test/test_files/IEEE_test_cases/300BUS.JPG index 4672084e6ded0b1872e4a2cbbc54013d33cae7ea..d560b74b67aa78e9e48e4f3eefed9d91692c28ba 100644 GIT binary patch delta 14 VcmZoz&eF7;rC|$WgD?{>7XT;W1Udi! delta 11 QcmZo#&e8xxTNoRJ0UKHbApigX diff --git a/test/test_files/IEEE_test_cases/30bus.jpg b/test/test_files/IEEE_test_cases/30bus.jpg index 91c2f7e610dc837f9a0e1a3c5315073bef1ea185..673bf6dcdb10dd185777c897e2db70c26194cb9c 100644 GIT binary patch delta 14 VcmZ2Bk!8h1mWC~i%Q%>Lxd19J1a$xa delta 11 ScmZ26k!9ILmWC~i%QyfW_XJ!3 diff --git a/test/test_files/IEEE_test_cases/57bus.jpg b/test/test_files/IEEE_test_cases/57bus.jpg index c62a057e019f3c746a79b7f06471413eb42923b8..9ce0952feefafb6ec5dd74c176ba0993e0c9ef64 100644 GIT binary patch delta 12 TcmX@UiRt7frVZ{hnRvMXCE5g{ delta 9 QcmX@PiRt(zrVZ{h0T>$ui2wiq diff --git a/test/test_files/IEEE_test_cases/IEEE 118.pdf b/test/test_files/IEEE_test_cases/IEEE 118.pdf index f8230391e86ccf9f0d2ef5757e5569d14c795b0f..59226a8bdbd5639bfd0afed6c2a7a302810baf70 100644 GIT binary patch delta 18 ZcmeCW&fjyLzoCV(g=q_O*J~zTE&xfU2D1PF delta 15 WcmeCV&fj&NzoCV(g=q_O*J}VZv<8|0 diff --git a/test/test_files/IEEE_test_cases/IEEE 57.pdf b/test/test_files/IEEE_test_cases/IEEE 57.pdf index e462cc77f31c07a2b1ef2256ad11c9ece3f89b4f..b6ea22e8a173e7e1fb7ddae506627c0ff4f215d7 100644 GIT binary patch delta 16 Xcmey}#`U+2tD%K)3sZG76E7D4KK2Fc delta 13 Ucmey{#`U|6tD%K)3sZG704-bv(f|Me diff --git a/test/test_files/IEEE_test_cases/IEEE 9.pdf b/test/test_files/IEEE_test_cases/IEEE 9.pdf index 0ecfe3869fa334185cb14ee4def2a99b520d4fba..940ce7ed5d353f61ae1552c1db1056335cfa229d 100644 GIT binary patch delta 16 Xcmex-iSz3v&W0AoElkCkOuSqGMQH|4 delta 13 Ucmex*iSzR%&W0AoElkCk05YQnHUIzs diff --git a/test/test_files/extraModel_tests/temperatures.bin b/test/test_files/extraModel_tests/temperatures.bin index 4b4688dedbd3ca37a6050f3952c9fa69a136f51e..e7467a4714d2335861dab579ea21db04e26111a6 100644 GIT binary patch delta 11 ScmdnEmvPfx#tj?e7`Xr;ECi|m delta 9 QcmdnAmvQ4>#tj?e02k#1p8x;= diff --git a/test/test_files/fmi_tests/test_fmus/DUMMY_0CYMDIST.fmu b/test/test_files/fmi_tests/test_fmus/DUMMY_0CYMDIST.fmu index aa01e87efb2bed6d06f40c3064454f3e02d169de..673f64ebc75a6679bb528cb38a82fc578f19ea38 100644 GIT binary patch delta 38 ucmdmb(`@@qvxXMN7N!>F7M2#)7Pc1l7LFFq7OocV7M?AF7M2#)7Pc1l7LFFq7OocV7M?A - - - - - - - - vanDerPol.fmu in branches/public/Test_FMUs/FMI_2.0/CoSimulation/win64/FMUSDK/2.0.4/vanDerPol - – FMI Issue Tracker - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- -
-

- -source: -branches/public/Test_FMUs/FMI_2.0/CoSimulation/win64/FMUSDK/2.0.4/vanDerPol/vanDerPol.fmu -
- -

-
-
-
- -
-
-
-
-
-
- - -
-
-
-
-
-
- - - -
-
-
-
-
- - - - - - - - - - - -
- Last change - on this file was - 2788, - checked in by adrian.tirea, 12 months ago -
-

-FMUSDK 2.0.4 test FMUs
-

-
-
    -
  • - Property svn:mime-type set to - application/octet-stream -
    • -
-
- File size: - 56.1 KB -
-
- -

- HTML preview not available, since no preview renderer could handle it. - Try downloading the file instead. -

- -
-
-
-
- - - - - -
-
-
-
Note: See TracBrowser - for help on using the repository browser.
-
- -
- - - \ No newline at end of file + + + + + + + + + vanDerPol.fmu in branches/public/Test_FMUs/FMI_2.0/CoSimulation/win64/FMUSDK/2.0.4/vanDerPol + – FMI Issue Tracker + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ +
+

+ +source: +branches/public/Test_FMUs/FMI_2.0/CoSimulation/win64/FMUSDK/2.0.4/vanDerPol/vanDerPol.fmu +
+ +

+
+
+
+ +
+
+
+
+
+
+ + +
+
+
+
+
+
+ + + +
+
+
+
+
+ + + + + + + + + + + +
+ Last change + on this file was + 2788, + checked in by adrian.tirea, 12 months ago +
+

+FMUSDK 2.0.4 test FMUs
+

+
+
    +
  • + Property svn:mime-type set to + application/octet-stream +
    • +
+
+ File size: + 56.1 KB +
+
+ +

+ HTML preview not available, since no preview renderer could handle it. + Try downloading the file instead. +

+ +
+
+
+
+ + + + + +
+
+
+
Note: See TracBrowser + for help on using the repository browser.
+
+ +
+ + + diff --git a/test/test_files/load_tests/FileLoadInfo.bin b/test/test_files/load_tests/FileLoadInfo.bin index 2316a1367024fb90352dffbbbb1c999a6b551e3d..eb3d03e03a56449061a398461ccb5cc385f4b769 100644 GIT binary patch delta 6 NcmYdHnvlrI1po)70l)wN delta 4 LcmYdFoRA0r1TX=$ diff --git a/test/test_files/load_tests/testLoad.bin b/test/test_files/load_tests/testLoad.bin index 24d8da6176742d3427f6cc005ea90fc52bc60045..07e355ae5a4983e0930b0e6d2f8695b8347a97d1 100644 GIT binary patch delta 11 ScmZ3nmvQA@#tkdt7`Xr-T?CH+ delta 9 QcmZ3vmvO~j#tkdt02fRIga7~l diff --git a/test/test_files/zip_tests/Rectifier.fmu b/test/test_files/zip_tests/Rectifier.fmu index 6a05bdd64aa49760236a5d3e32a01ecbf821fb56..5420e18d410af0b9a7da9068b6b213fa78a862e2 100644 GIT binary patch delta 54 zcmV~$M-hN9006L~?6Q}(+TjsNI6*`Y7bN*j- Date: Thu, 28 May 2026 05:52:20 -0700 Subject: [PATCH 5/5] clang-tidy fixes --- src/fileInput/readSolverElement.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/fileInput/readSolverElement.cpp b/src/fileInput/readSolverElement.cpp index 1d1a42b85..349e0cf94 100644 --- a/src/fileInput/readSolverElement.cpp +++ b/src/fileInput/readSolverElement.cpp @@ -25,7 +25,7 @@ namespace { } // namespace void loadSolverElement(std::shared_ptr& element, - ReaderInfo& ReaderInformation, + ReaderInfo& readerInformation, GridDynSimulation* parentObject) { std::shared_ptr solverDefinition; @@ -90,8 +90,8 @@ void loadSolverElement(std::shared_ptr& element, } setAttributes( - solverDefinition.get(), element, "solver", ReaderInformation, solverIgnoreFields()); - setParams(solverDefinition.get(), element, "solver", ReaderInformation, solverIgnoreFields()); + solverDefinition.get(), element, "solver", readerInformation, solverIgnoreFields()); + setParams(solverDefinition.get(), element, "solver", readerInformation, solverIgnoreFields()); // add the solver parentObject->add(solverDefinition); }