Scalable Microgrid

CMake/FindSuiteSparse.cmake

@@ -69,11 +69,11 @@ Author(s):
 set(SUITESPARSE_MODULES
   amd
   colamd
-  klu)
+  klu
+  suitesparseconfig)
 
 find_library(SUITESPARSE_LIBRARY
   NAMES
-  suitesparseconfig
   ${SUITESPARSE_MODULES}
   PATHS
   ${SUITESPARSE_DIR} $ENV{SUITESPARSE_DIR} ${SUITESPARSE_ROOT_DIR}
@@ -97,6 +97,7 @@ find_path(SUITESPARSE_INCLUDE_DIR
   amd.h
   colamd.h
   klu.h
+  SuiteSparse_config.h
   PATHS
   ${SUITESPARSE_DIR} $ENV{SUITESPARSE_DIR} ${SUITESPARSE_ROOT_DIR} ${SUITESPARSE_LIBRARY_DIR}/..
   PATH_SUFFIXES

CMakeLists.txt

@@ -81,11 +81,14 @@ option(GRIDKIT_ENABLE_IPOPT "Enable Ipopt support" ON)
 option(GRIDKIT_ENABLE_SUNDIALS "Enable SUNDIALS support" ON)
 
 # Enable KLU
-option(GRIDKIT_ENABLE_SUNDIALS_SPARSE "Enable SUNDIALS sparse linear solvers" OFF)
+option(GRIDKIT_ENABLE_SUNDIALS_SPARSE "Enable SUNDIALS sparse linear solvers" ON)
 
 
 set(CMAKE_MACOSX_RPATH 1)
 
+#Provide string to source
+add_compile_definitions("SOURCE_ROOT=${CMAKE_SOURCE_DIR}")
+
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/CMake)
 
 # https://gitlab.kitware.com/cmake/community/-/wikis/doc/cmake/RPATH-handling#always-full-rpath
@@ -110,7 +113,7 @@ endif("${isSystemDir}" STREQUAL "-1")
 
 
 # TODO: Probably beter to set a debug interface target
-set(CMAKE_CXX_FLAGS_DEBUG "-Wall -O0 -g")
+set(CMAKE_CXX_FLAGS_DEBUG "-Wall -O0 -g -DDEBUG")
 
 set(CMAKE_CXX_STANDARD 17)
 
@@ -143,6 +146,9 @@ add_subdirectory(ComponentLib)
 # General Utilities and File IO
 add_subdirectory(Utilities)
 
+#Local Sparse matrix operations
+add_subdirectory(SparseMatrix)
+
 # Create solvers
 add_subdirectory(Solver)
 

CircuitGraph.hpp

@@ -0,0 +1,119 @@
+
+
+#include <iostream>
+#include <cmath>
+#include <vector>
+#include <unordered_set>
+#include <map>
+
+/**
+ * @brief A very basic hypergraph setup for circuit representation. This forms the hypergraph as a bipartite graph. Doesn't allow removing. Can only grab sets of connections to nodes
+ * 
+ * @todo should replace with something better and more efficent. Should replace with a libraries setup instead. This would allow fast and easy partitioning of circuits
+ * 
+ * @todo should replace N and E with Node and Component classes respectively
+ * 
+ * @tparam IdxT 
+ * @tparam Label 
+ */
+template <typename N, typename E>
+class CircuitGraph
+{
+private:
+	std::set<N> hypernodes;
+	std::set<E> hyperedges;
+	std::map<E, std::set<N>> edgestonodes;
+public:
+	CircuitGraph();
+	~CircuitGraph();
+	bool addHyperEdge(E he);
+	bool addHyperNode(N hn);
+	bool addConnection(N hn, E he);
+	std::set<N> getHyperEdgeConnections(E he);
+	size_t amountHyperNodes();
+	size_t amountHyperEdges();
+	void printBiPartiteGraph(bool verbose = false);
+};
+
+template <typename N, typename E>
+CircuitGraph<N, E>::CircuitGraph()
+{
+}
+
+template <typename N, typename E>
+CircuitGraph<N, E>::~CircuitGraph()
+{
+}
+
+template <typename N, typename E>
+bool  CircuitGraph<N, E>::addHyperNode(N hn)
+{
+	return this->hypernodes.insert(hn).second;
+}
+
+template <typename N, typename E>
+bool  CircuitGraph<N, E>::addHyperEdge(E he)
+{
+	return this->hyperedges.insert(he).second;
+}
+
+
+template <typename N, typename E>
+bool  CircuitGraph<N, E>::addConnection(N hn, E he)
+{
+	if(this->hyperedges.count(he) == 0 || this->hypernodes.count(hn) == 0)
+	{
+		return false;
+	} 
+	return this->edgestonodes[he].insert(hn).second;
+}
+
+
+template <typename N, typename E>
+std::set<N>  CircuitGraph<N, E>::getHyperEdgeConnections(E he)
+{
+	return this->edgestonodes[he];
+}
+
+
+template <typename N, typename E>
+size_t  CircuitGraph<N, E>::amountHyperNodes()
+{
+	return this->hypernodes.size();
+}
+
+
+template <typename N, typename E>
+size_t  CircuitGraph<N, E>::amountHyperEdges()
+{
+	return this->hyperedges.size();
+}
+
+/**
+ * @brief Printing
+ * 
+ * @todo need to add verbose printing for connections display
+ * 
+ * @tparam IdxT 
+ * @param verbose 
+ */
+
+template <typename N, typename E>
+void CircuitGraph<N, E>::printBiPartiteGraph(bool verbose)
+{
+
+	std::cout << "Amount of HyperNodes: " << this->amountHyperNodes() << std::endl;
+	std::cout << "Amount of HyperEdges: " << this->amountHyperEdges() << std::endl;
+	std::cout << "Connections per Edge:" << std::endl;
+	for (auto i : this->edgestonodes)
+	{
+		std::cout << i.first << " : {";
+		for (auto j : i.second){
+			std::cout << j << ", ";
+		}
+		std::cout << "}\n";
+
+	}
+
+
+}

ComponentLib/Bus/BusFactory.hpp

@@ -97,4 +97,4 @@ namespace ModelLib {
         }
     };
 
-} // namespace ModelLib
+} // namespace ModelLib

ComponentLib/Bus/BusPV.cpp

@@ -95,7 +95,7 @@ template <class ScalarT, typename IdxT>
 BusPV<ScalarT, IdxT>::BusPV(ScalarT V, ScalarT theta0)
   : BaseBus<ScalarT, IdxT>(0), V_(V), theta0_(theta0)
 {
-    //std::cout << "Create BusPV..." << std::endl;
+    //std::cout << "Create BusPV ..." << std::endl;
     //std::cout << "Number of equations is " << size_ << std::endl;
 
     size_ = 1;

ComponentLib/CMakeLists.txt

@@ -69,3 +69,5 @@ add_subdirectory(Generator4Governor)
 add_subdirectory(Generator4Param)
 add_subdirectory(Load)
 add_subdirectory(MiniGrid)
+add_subdirectory(PowerElectronicsComponents)
+

ComponentLib/Generator/GeneratorPV.hpp

@@ -124,18 +124,14 @@ namespace ModelLib
             return P_;
         }
 
-        /// @brief  Reactive power excess on PV bus
-        /// @return reference to negative PV generator reactive power
         virtual ScalarT& Q()
         {
-            return (bus_->Q());
+            return bus_->Q();
         }
 
-        /// @brief  Reactive power excess on PV bus
-        /// @return const reference to negative PV generator reactive power
         virtual const ScalarT& Q() const
         {
-            return (bus_->Q());
+            return bus_->Q();
         }
 
     private:

ComponentLib/PowerElectronicsComponents/CMakeLists.txt

@@ -0,0 +1,14 @@
+
+
+add_subdirectory(Capacitor)
+add_subdirectory(Resistor)
+add_subdirectory(VoltageSource)
+add_subdirectory(Inductor)
+add_subdirectory(LinearTransformer)
+add_subdirectory(InductionMotor)
+add_subdirectory(SynchronousMachine)
+add_subdirectory(DiscreteGenerator)
+add_subdirectory(TransmissionLine)
+add_subdirectory(MicrogridLoad)
+add_subdirectory(MicrogridLine)
+add_subdirectory(MicrogridBusDQ)

ComponentLib/PowerElectronicsComponents/Capacitor/CMakeLists.txt

@@ -0,0 +1,8 @@
+
+
+
+gridkit_add_library(powerelec_capacitor
+  SOURCES
+    Capacitor.cpp
+  OUTPUT_NAME
+    gridkit_powerelec_capacitor)

ComponentLib/PowerElectronicsComponents/Capacitor/Capacitor.cpp

@@ -0,0 +1,137 @@
+
+
+
+#include <iostream>
+#include <cmath>
+#include <vector>
+#include "Capacitor.hpp"
+
+namespace ModelLib {
+
+/*!
+ * @brief Constructor for a constant load model
+ *
+ * Calls default ModelEvaluatorImpl constructor.
+ */
+
+template <class ScalarT, typename IdxT>
+Capacitor<ScalarT, IdxT>::Capacitor(IdxT id, ScalarT C)
+  :  C_(C)
+{
+	this->size_ = 3;
+    this->n_intern = 1;
+    this->n_extern = 2;
+    this->extern_indices = {0,1};
+    this->idc_ = id;
+}
+
+template <class ScalarT, typename IdxT>
+Capacitor<ScalarT, IdxT>::~Capacitor()
+{
+}
+
+/*!
+ * @brief allocate method computes sparsity pattern of the Jacobian.
+ */
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::allocate()
+{
+    this->y_.resize(this->size_);
+    this->yp_.resize(this->size_);
+    this->f_.resize(this->size_);
+
+    return 0;
+}
+
+/**
+ * Initialization of the grid model
+ */
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::initialize()
+{
+    return 0;
+}
+
+/*
+ * \brief Identify differential variables
+ */
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::tagDifferentiable()
+{
+    return 0;
+}
+
+/**
+ * @brief Contributes to the bus residual.
+ *
+ * Must be connected to a PQ bus.
+ */
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::evaluateResidual()
+{
+    //input
+    this->f_[0] = C_ * this->yp_[2];
+    //output
+    this->f_[1] = -C_ * this->yp_[2];
+
+    //internal
+    this->f_[2] =  -C_ * this->yp_[2] + this->y_[0] - this->y_[1] - this->y_[2];
+    return 0;
+}
+
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::evaluateJacobian()
+{
+    this->J_.zeroMatrix();
+    //Create dF/dy
+    std::vector<IdxT> rcord{2,2,2};
+    std::vector<IdxT> ccord{0,1,2};
+    std::vector<ScalarT> vals{1.0, -1.0, -1.0};
+    this->J_.setValues(rcord, ccord, vals);
+
+    //Create -dF/dy'
+    std::vector<IdxT> rcordder{0,1,2};
+    std::vector<IdxT> ccordder{2,2,2};
+    std::vector<ScalarT> valsder{C_, -C_, -this->C_};
+    COO_Matrix<ScalarT,IdxT> Jacder = COO_Matrix<ScalarT, IdxT>(rcordder, ccordder, valsder,3,3);
+
+    //Perform dF/dy + \alpha dF/dy'
+    this->J_.AXPY(this->alpha_, Jacder);
+
+    return 0;
+}
+
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::evaluateIntegrand()
+{
+    return 0;
+}
+
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::initializeAdjoint()
+{
+    return 0;
+}
+
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::evaluateAdjointResidual()
+{
+    return 0;
+}
+
+template <class ScalarT, typename IdxT>
+int Capacitor<ScalarT, IdxT>::evaluateAdjointIntegrand()
+{
+    return 0;
+}
+
+
+
+
+// Available template instantiations
+template class Capacitor<double, long int>;
+template class Capacitor<double, size_t>;
+
+
+} //namespace ModelLib
+