Skip to content

Refactoring phasor dynamics constituent models #381

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
pelesh merged 2 commits into from
Apr 30, 2026
Merged

Refactoring phasor dynamics constituent models #381

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4a70522
Add ConstituentModel as base for components and buses; removed Signal…
PhilipFackler Apr 23, 2026
7230d20
Changed class name
PhilipFackler Apr 27, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
291 changes: 11 additions & 280 deletions GridKit/Model/PhasorDynamics/BusBase.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,8 +6,8 @@

#include <GridKit/AutomaticDifferentiation/DependencyTracking/Variable.hpp>
#include <GridKit/Constants.hpp>
#include <GridKit/Model/Evaluator.hpp>
#include <GridKit/Model/PhasorDynamics/Bus/BusData.hpp>
#include <GridKit/Model/PhasorDynamics/GridElement.hpp>
#include <GridKit/Model/VariableMonitor.hpp>
#include <GridKit/Utilities/Logger/Logger.hpp>

Expand All @@ -22,11 +22,11 @@ namespace GridKit
*
*/
template <typename ScalarT, typename IdxT>
class BusBase : public Model::Evaluator<ScalarT, IdxT>
class BusBase : public GridElement<ScalarT, IdxT>
{
public:
using RealT = typename Model::Evaluator<ScalarT, IdxT>::RealT;
using MatrixT = typename Model::Evaluator<ScalarT, IdxT>::MatrixT;
using RealT = typename GridElement<ScalarT, IdxT>::RealT;
using MatrixT = typename GridElement<ScalarT, IdxT>::MatrixT;
using BusTypeT = typename BusData<RealT, IdxT>::BusType;
using MonitorT = Model::VariableMonitor<BusBase, BusData>;

Expand All @@ -36,43 +36,27 @@ namespace GridKit

virtual ~BusBase();

/// Pure virtual function, returns bus type (DEFAULT or SLACK).
virtual BusTypeT BusType() const
int verify() const override
{
return BusTypeT::DEFAULT;
}

virtual IdxT size() override
{
return size_;
return 0;
}

virtual IdxT nnz() override
/// Pure virtual function, returns bus type (DEFAULT or SLACK).
virtual BusTypeT BusType() const
{
return nnz_;
return BusTypeT::DEFAULT;
}

virtual bool hasJacobian() override
bool hasJacobian() override
{
return false;
}

virtual void updateTime(RealT /* t */, RealT /* a */) override
void updateTime(RealT /* t */, RealT /* a */) override
{
// No time to update in bus models
}

virtual void setTolerances(RealT& rtol, RealT& atol) const override
{
rtol = rtol_;
atol = atol_;
}

virtual void setMaxSteps(IdxT& msa) const override
{
msa = max_steps_;
}

virtual ScalarT& Vr() = 0;
virtual const ScalarT& Vr() const = 0;
virtual ScalarT& Vi() = 0;
Expand All @@ -82,273 +66,20 @@ namespace GridKit
virtual ScalarT& Ii() = 0;
virtual const ScalarT& Ii() const = 0;

std::vector<ScalarT>& y() override
{
return y_;
}

const std::vector<ScalarT>& y() const override
{
return y_;
}

std::vector<ScalarT>& yp() override
{
return yp_;
}

const std::vector<ScalarT>& yp() const override
{
return yp_;
}

std::vector<bool>& tag() override
{
return tag_;
}

const std::vector<bool>& tag() const override
{
return tag_;
}

MatrixT& getJacobian() override
{
return J_;
}

const MatrixT& getJacobian() const override
{
return J_;
}

virtual int setBusID(IdxT) = 0;

virtual const IdxT busID() const
{
return bus_id_;
}

int setVariableIndex(IdxT local_index, IdxT global_index)
{
variable_indices_[static_cast<size_t>(local_index)] = global_index;
return 0;
}

IdxT getVariableIndex(IdxT local_index) const
{
return variable_indices_[static_cast<size_t>(local_index)];
}

const std::vector<IdxT>& getVariableIndices() const
{
return variable_indices_;
}

int setResidualIndex(IdxT local_index, IdxT global_index)
{
residual_indices_[static_cast<size_t>(local_index)] = global_index;
return 0;
}

IdxT getResidualIndex(IdxT local_index) const
{
return residual_indices_[static_cast<size_t>(local_index)];
}

const std::vector<IdxT>& getResidualIndices() const
{
return residual_indices_;
}

const Model::VariableMonitorBase* getMonitor() const override;

protected:
IdxT bus_id_{INVALID_INDEX<IdxT>};

IdxT size_{0};
IdxT nnz_{0};
std::vector<IdxT> variable_indices_; ///< Global (system-level) variable indices
std::vector<IdxT> residual_indices_; ///< Global (system-level) residual indices

/// Variable monitor
std::unique_ptr<MonitorT> monitor_;

std::vector<ScalarT> y_;
std::vector<ScalarT> yp_;
std::vector<bool> tag_;
std::vector<ScalarT> f_;

MatrixT J_;
IdxT* J_rows_buffer_{nullptr};
IdxT* J_cols_buffer_{nullptr};
RealT* J_vals_buffer_{nullptr};

RealT rtol_;
RealT atol_;

IdxT max_steps_;

//
// Adjoint sensitivity members
//

std::vector<ScalarT> g_{};
std::vector<ScalarT> yB_{};
std::vector<ScalarT> ypB_{};
std::vector<ScalarT> fB_{};
std::vector<ScalarT> gB_{};

std::vector<ScalarT> param_{};
std::vector<ScalarT> param_up_{};
std::vector<ScalarT> param_lo_{};

//
// Public adjoint sensitivity methods (not yet implemented in components)
//

public:
virtual IdxT sizeQuadrature() override
{
throw "ERROR: Method not implemented!\n";
return 0;
}

virtual IdxT sizeParams() override
{
throw "ERROR: Method not implemented!\n";
return 0;
}

std::vector<ScalarT>& yB() override
{
throw "ERROR: Method not implemented!\n";
return yB_;
}

const std::vector<ScalarT>& yB() const override
{
throw "ERROR: Method not implemented!\n";
return yB_;
}

std::vector<ScalarT>& ypB() override
{
throw "ERROR: Method not implemented!\n";
return ypB_;
}

const std::vector<ScalarT>& ypB() const override
{
throw "ERROR: Method not implemented!\n";
return ypB_;
}

std::vector<ScalarT>& param() override
{
throw "ERROR: Method not implemented!\n";
return param_;
}

const std::vector<ScalarT>& param() const override
{
throw "ERROR: Method not implemented!\n";
return param_;
}

std::vector<ScalarT>& param_up() override
{
throw "ERROR: Method not implemented!\n";
return param_up_;
}

const std::vector<ScalarT>& param_up() const override
{
throw "ERROR: Method not implemented!\n";
return param_up_;
}

std::vector<ScalarT>& param_lo() override
{
throw "ERROR: Method not implemented!\n";
return param_lo_;
}

const std::vector<ScalarT>& param_lo() const override
{
throw "ERROR: Method not implemented!\n";
return param_lo_;
}

int evaluateIntegrand() override
{
throw "ERROR: Method not implemented!\n";
return 1;
}

int initializeAdjoint() override
{
throw "ERROR: Method not implemented!\n";
return 1;
}

int evaluateAdjointResidual() override
{
throw "ERROR: Method not implemented!\n";
return 1;
}

int evaluateAdjointIntegrand() override
{
throw "ERROR: Method not implemented!\n";
return 1;
}

std::vector<ScalarT>& getResidual() override
{
return f_;
}

const std::vector<ScalarT>& getResidual() const override
{
return f_;
}

std::vector<ScalarT>& getIntegrand() override
{
throw "ERROR: Method not implemented!\n";
return g_;
}

const std::vector<ScalarT>& getIntegrand() const override
{
throw "ERROR: Method not implemented!\n";
return g_;
}

std::vector<ScalarT>& getAdjointResidual() override
{
throw "ERROR: Method not implemented!\n";
return fB_;
}

const std::vector<ScalarT>& getAdjointResidual() const override
{
throw "ERROR: Method not implemented!\n";
return fB_;
}

std::vector<ScalarT>& getAdjointIntegrand() override
{
throw "ERROR: Method not implemented!\n";
return gB_;
}

const std::vector<ScalarT>& getAdjointIntegrand() const override
{
throw "ERROR: Method not implemented!\n";
return gB_;
}
};

} // namespace PhasorDynamics
Expand Down
9 changes: 0 additions & 9 deletions GridKit/Model/PhasorDynamics/BusBaseImpl.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,15 +26,6 @@ namespace GridKit
template <typename ScalarT, typename IdxT>
BusBase<ScalarT, IdxT>::~BusBase()
{
if (J_rows_buffer_ != nullptr)
{
delete[] J_rows_buffer_;
delete[] J_cols_buffer_;
delete[] J_vals_buffer_;
J_rows_buffer_ = nullptr;
J_cols_buffer_ = nullptr;
J_vals_buffer_ = nullptr;
}
}

template <typename ScalarT, typename IdxT>
Expand Down
2 changes: 2 additions & 0 deletions GridKit/Model/PhasorDynamics/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,10 +11,12 @@ gridkit_add_library(phasor_dynamics_core
SystemModelData.cpp
HEADERS
BusBase.hpp
BusBaseImpl.hpp
Component.hpp
ComponentData.hpp
ComponentLibrary.hpp
ComponentSignals.hpp
GridElement.hpp
SystemModel.hpp
SystemModelData.hpp
LINK_LIBRARIES
Expand Down
Loading
Loading